diff --git a/GHC/CString.hs b/GHC/CString.hs
--- a/GHC/CString.hs
+++ b/GHC/CString.hs
@@ -1,11 +1,11 @@
-{-# LANGUAGE MagicHash, NoImplicitPrelude, BangPatterns #-}
+{-# LANGUAGE MagicHash, NoImplicitPrelude, BangPatterns, UnliftedFFITypes #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.CString
-- Copyright : (c) The University of Glasgow 2011
-- License : see libraries/ghc-prim/LICENSE
--
--- Maintainer : cvs-ghc@haskell.org
+-- Maintainer : ghc-devs@haskell.org
-- Stability : internal
-- Portability : non-portable (GHC Extensions)
--
@@ -16,15 +16,80 @@
-----------------------------------------------------------------------------
module GHC.CString (
+ -- * Ascii variants
unpackCString#, unpackAppendCString#, unpackFoldrCString#,
- unpackCStringUtf8#, unpackNBytes#
+ cstringLength#,
+
+ -- * Utf variants
+ unpackCStringUtf8#, unpackAppendCStringUtf8#, unpackFoldrCStringUtf8#,
+
+ -- * Other
+ unpackNBytes#,
) where
-import GHC.Types
+import GHC.Types hiding (One)
import GHC.Prim
+{-
+Note [String literals in GHC]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+String literals get quite a bit of special handling in GHC. This Note
+summarises the moving parts.
+
+* Desugaring: see GHC.HsToCore.Match.Literal.dsLit, which in
+ turn calls GHC.Core.Make.mkStringExprFS.
+
+ The desugarer desugars the Haskell literal "foo" into Core
+ GHC.CString.unpackCString# "foo"#
+ where "foo"# is primitive string literal (of type Addr#).
+
+ When the string cannot be encoded as a C string, we use UTF8:
+ GHC.CString.unpackCStringUtf8# "foo"#
+
+* The library module ghc-prim:GHC.CString has a bunch of functions that
+ work over primitive strings, including GHC.CString.unpackCString#
+
+* GHC.Core.Op.ConstantFold has some RULES that optimise certain string
+ operations on literal strings. For example:
+
+ + Constant folding the desugared form of ("foo" ++ "bar")
+ into ("foobar")
+ + Comparing strings
+ + and more
+
+* GHC.Base has a number of regular rules for String literals.
+
+ + a rule "eqString": (==) @String = eqString
+ where GHC.Base.eqString :: String -> String -> Bool
+
+ ConstantFold has a RULE for eqString on literals:
+ eqString (Lit "foo"#) (Lit "bar"#) --> False
+
+ This allows compile time evaluation of things like "foo" == "bar"
+
+ + A bunch of rules to promote fusion:
+
+ "unpack" [~1] forall a . unpackCString# a = build (unpackFoldrCString# a)
+ "unpack-list" [1] forall a . unpackFoldrCString# a (:) [] = unpackCString# a
+ "unpack-append" forall a n . unpackFoldrCString# a (:) n = unpackAppendCString# a n
+
+ And UTF8 variants of these rules.
+
+* We allow primitive (unlifted) literal strings to be top-level
+ bindings, breaking out usual rule. See GHC.Core
+ Note [Core top-level string literals]
+
+* TODO: There is work on a special code-gen path for top-level boxed strings
+ str :: [Char]
+ str = unpackCString# "foo"#
+ so that they can all share a common code pointer
+
+ There is a WIP MR on gitlab for this: !3012
+
+-}
+
-----------------------------------------------------------------------------
--- Unpacking C strings}
+-- Unpacking C strings
-----------------------------------------------------------------------------
-- This code is needed for virtually all programs, since it's used for
@@ -34,89 +99,250 @@
-- 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 GHC.Core.Opt.ConstantFold; 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
+
+Moreover, we want to make it CONLIKE, so that:
+
+* the rules in GHC.Core.Opt.ConstantFold will fire when the string is let-bound.
+ E.g. the eqString rule in GHC.Core.Opt.ConstantFold
+ eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1==s2
+
+* exprIsConApp_maybe will see the string when we have
+ let x = unpackCString# "foo"#
+ ...(case x of algs)...
+
+All of this goes for unpackCStringUtf8# too.
+-}
+
+{-
+Note [Inlining of unpackFoldrCString]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Usually the unpack-list rule turns unpackFoldrCString# into unpackCString#
+It also has a BuiltInRule in PrelRules.hs:
+ unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)
+ = unpackFoldrCString# "foobaz" c n
+
+We use NOINLINE [0] on the grounds that, unlike
+unpackCString#, there *is* some point in inlining
+unpackFoldrCString#, because we get better code for the
+higher-order function call.
+
+This can cause a code size increase but it was minimal
+when looking at nofib.
+
+This is especially important for elem which then results in an
+allocation free loop.
+
+Note [unpackCString# iterating over addr]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When unpacking unpackCString# and friends repeatedly return a cons cell
+containing:
+* The current character we just unpacked.
+* A thunk to unpack the rest of the string.
+
+In order to minimize the size of the thunk we do not index of
+the start of the string, offsetting into it, but instead increment
+the addr and always use offset 0#.
+
+This works since these two expressions will read from the same address.
+* `indexCharOffAddr# a i`
+* `indexCharOffAddr (a `plusAddr#` i) 0#`
+
+This way we avoid the need for the thunks to close over both the start of
+the string and the current offset, saving a word for each character unpacked.
+
+This has the additional advantage the we can guarantee that only the
+increment will happen in the loop.
+-}
+
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
+{-# NOINLINE CONLIKE unpackCString# #-}
unpackCString# addr
- = unpack 0#
- where
- unpack nh
- | isTrue# (ch `eqChar#` '\0'#) = []
- | True = C# ch : unpack (nh +# 1#)
+ | isTrue# (ch `eqChar#` '\0'#) = []
+ | True = C# ch : unpackCString# (addr `plusAddr#` 1#)
where
- !ch = indexCharOffAddr# addr nh
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
+
unpackAppendCString# :: Addr# -> [Char] -> [Char]
{-# NOINLINE unpackAppendCString# #-}
-- See the NOINLINE note on unpackCString#
unpackAppendCString# addr rest
- = unpack 0#
- where
- unpack nh
- | isTrue# (ch `eqChar#` '\0'#) = rest
- | True = C# ch : unpack (nh +# 1#)
+ | isTrue# (ch `eqChar#` '\0'#) = rest
+ | True = C# ch : unpackAppendCString# (addr `plusAddr#` 1#) rest
where
- !ch = indexCharOffAddr# addr nh
-
-unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
-
--- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString#
-
--- It also has a BuiltInRule in PrelRules.lhs:
--- unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)
--- = unpackFoldrCString# "foobaz" c n
-
-{-# NOINLINE unpackFoldrCString# #-}
--- At one stage I had NOINLINE [0] on the grounds that, unlike
--- unpackCString#, there *is* some point in inlining
--- unpackFoldrCString#, because we get better code for the
--- higher-order function call. BUT there may be a lot of
--- literal strings, and making a separate 'unpack' loop for
--- each is highly gratuitous. See nofib/real/anna/PrettyPrint.
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
-unpackFoldrCString# addr f z
- = unpack 0#
+-- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString#.
+-- See Note [String literals in GHC] for more details.
+-- See [Inlining of unpackFoldrCString]
+{-# NOINLINE[0] unpackFoldrCString# #-}
+unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
+unpackFoldrCString# str f z_init = go str z_init
where
- unpack nh
+ go addr z
| isTrue# (ch `eqChar#` '\0'#) = z
- | True = C# ch `f` unpack (nh +# 1#)
+ | True = C# ch `f` go (addr `plusAddr#` 1#) z
where
- !ch = indexCharOffAddr# addr nh
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
+-- 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 CONLIKE unpackCStringUtf8# #-}
unpackCStringUtf8# addr
- = unpack 0#
+ | isTrue# (ch `eqChar#` '\0'# ) = []
+ | True =
+ let !byte_count = getByteCount ch
+ !utf_ch = unpackUtf8Char# byte_count ch addr
+ !addr' = addr `plusBytes` byte_count
+ in C# utf_ch : unpackCStringUtf8# addr'
+ where
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
+
+unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char]
+{-# NOINLINE unpackAppendCStringUtf8# #-}
+ -- See the NOINLINE note on unpackCString#
+unpackAppendCStringUtf8# addr rest
+ | isTrue# (ch `eqChar#` '\0'#) = rest
+ | True =
+ let !byte_count = getByteCount ch
+ !utf_ch = unpackUtf8Char# byte_count ch addr
+ !addr' = (addr `plusBytes` byte_count)
+ in C# utf_ch : unpackAppendCStringUtf8# addr' rest
+ where
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
+
+-- See Note [Inlining of unpackFoldrCString]
+{-# NOINLINE[0] unpackFoldrCStringUtf8# #-}
+unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a
+unpackFoldrCStringUtf8# addr_init f z_init
+ = go addr_init z_init
where
- unpack nh
- | isTrue# (ch `eqChar#` '\0'# ) = []
- | isTrue# (ch `leChar#` '\x7F'#) = C# ch : unpack (nh +# 1#)
- | isTrue# (ch `leChar#` '\xDF'#) =
- C# (chr# (((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6#) +#
- (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#))) :
- unpack (nh +# 2#)
- | isTrue# (ch `leChar#` '\xEF'#) =
- C# (chr# (((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12#) +#
- ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 6#) +#
- (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#))) :
- unpack (nh +# 3#)
- | True =
- C# (chr# (((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18#) +#
- ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12#) +#
- ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#` 6#) +#
- (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#))) :
- unpack (nh +# 4#)
+ go addr z
+ | isTrue# (ch `eqChar#` '\0'#) = z
+ | True =
+ let !byte_count = getByteCount ch
+ !utf_ch = unpackUtf8Char# byte_count ch addr
+ !addr' = (addr `plusBytes` byte_count)
+ in C# utf_ch `f` go addr' z
where
- !ch = indexCharOffAddr# addr nh
+ -- See Note [unpackCString# iterating over addr]
+ !ch = indexCharOffAddr# addr 0#
+-- 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
+ unpack :: [Char] -> Int# -> [Char]
unpack acc i#
| isTrue# (i# <# 0#) = acc
| True =
case indexCharOffAddr# addr i# of
ch -> unpack (C# ch : acc) (i# -# 1#)
+-- The return type is not correct here. We really want CSize,
+-- but that type is defined in base. However, CSize should always
+-- match the size of a machine word (I hope), so this is probably
+-- alright on all platforms that GHC supports.
+foreign import ccall unsafe "strlen" c_strlen :: Addr# -> Int#
+
+-- | Compute the length of a NUL-terminated string. This address
+-- must refer to immutable memory. GHC includes a built-in rule for
+-- constant folding when the argument is a statically-known literal.
+-- That is, a core-to-core pass reduces the expression
+-- @cstringLength# "hello"#@ to the constant @5#@.
+cstringLength# :: Addr# -> Int#
+{-# INLINE[0] cstringLength# #-}
+cstringLength# = c_strlen
+
+
+------------------------------
+--- UTF-8 decoding utilities
+------------------------------
+--
+-- This is one of several UTF-8 implementations provided by GHC; see Note
+-- [GHC's many UTF-8 implementations] in "GHC.Encoding.UTF8" for an
+-- overview.
+--
+-- These functions make explicit the logic that was originally
+-- part of unpackCStringUtf8. Since we want the same support for ascii
+-- and non-ascii a variety of functions needs the same logic. Instead
+-- of C&P'in the decoding logic all over we have it here once, and then
+-- force GHC to inline it.
+--
+-- All the overhead of the Bytes argument and calls goes away once all is
+-- said and done. And what remains is readable code in Haskell land and
+-- performant code in the resulting binary.
+
+data Bytes = One | Two | Three | Four
+
+{-# INLINE getByteCount #-}
+getByteCount :: Char# -> Bytes
+getByteCount ch
+ | isTrue# (ch `leChar#` '\x7F'#) = One
+ | isTrue# (ch `leChar#` '\xDF'#) = Two
+ | isTrue# (ch `leChar#` '\xEF'#) = Three
+ | True = Four
+
+{-# INLINE plusBytes #-}
+plusBytes :: Addr# -> Bytes -> Addr#
+plusBytes addr bytes =
+ case bytes of
+ One -> addr `plusAddr#` 1#
+ Two -> addr `plusAddr#` 2#
+ Three -> addr `plusAddr#` 3#
+ Four -> addr `plusAddr#` 4#
+
+-- | Take the current address, read unicode char of the given size.
+-- We obviously want the number of bytes, but we have to read one
+-- byte to determine the number of bytes for the current codepoint
+-- so we might as well reuse it and avoid a read.
+--
+-- Side Note: We don't dare to decode all 4 possibilities at once.
+-- Reading past the end of the addr might trigger an exception.
+-- For this reason we really have to check the width first and only
+-- decode after.
+{-# INLINE unpackUtf8Char# #-}
+unpackUtf8Char# :: Bytes -> Char# -> Addr# -> Char#
+unpackUtf8Char# bytes ch addr =
+ case bytes of
+ One -> ch
+ Two -> (chr# (((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6#) +#
+ (ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#)))
+ Three -> (chr# (((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12#) +#
+ ((ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#) `uncheckedIShiftL#` 6#) +#
+ (ord# (indexCharOffAddr# (addr `plusAddr#` 2#) 0#) -# 0x80#)))
+ Four -> (chr# (((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18#) +#
+ ((ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#) `uncheckedIShiftL#` 12#) +#
+ ((ord# (indexCharOffAddr# (addr `plusAddr#` 2#) 0#) -# 0x80#) `uncheckedIShiftL#` 6#) +#
+ (ord# (indexCharOffAddr# (addr `plusAddr#` 3#) 0#) -# 0x80#)))
diff --git a/GHC/Classes.hs b/GHC/Classes.hs
--- a/GHC/Classes.hs
+++ b/GHC/Classes.hs
@@ -1,299 +1,1608 @@
{-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns #-}
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
--- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh.
-{-# OPTIONS_HADDOCK hide #-}
------------------------------------------------------------------------------
--- |
--- Module : GHC.Classes
--- Copyright : (c) The University of Glasgow, 1992-2002
--- License : see libraries/base/LICENSE
---
--- Maintainer : cvs-ghc@haskell.org
--- Stability : internal
--- Portability : non-portable (GHC extensions)
---
--- Basic classes.
---
------------------------------------------------------------------------------
-
-module GHC.Classes where
-
--- GHC.Magic is used in some derived instances
-import GHC.Magic ()
-import GHC.Prim
-import GHC.Tuple
-import GHC.Types
-
-
-infix 4 ==, /=, <, <=, >=, >
-infixr 3 &&
-infixr 2 ||
-
-default () -- Double isn't available yet
-
--- | The 'Eq' class defines equality ('==') and inequality ('/=').
--- All the basic datatypes exported by the "Prelude" are instances of 'Eq',
--- and 'Eq' may be derived for any datatype whose constituents are also
--- instances of 'Eq'.
---
--- Minimal complete definition: either '==' or '/='.
---
-class Eq a where
- (==), (/=) :: a -> a -> Bool
-
- {-# INLINE (/=) #-}
- {-# INLINE (==) #-}
- x /= y = not (x == y)
- x == y = not (x /= y)
- {-# MINIMAL (==) | (/=) #-}
-
-deriving instance Eq ()
-deriving instance (Eq a, Eq b) => Eq (a, b)
-deriving instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
-deriving instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f)
- => Eq (a, b, c, d, e, f)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g)
- => Eq (a, b, c, d, e, f, g)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h)
- => Eq (a, b, c, d, e, f, g, h)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i)
- => Eq (a, b, c, d, e, f, g, h, i)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j)
- => Eq (a, b, c, d, e, f, g, h, i, j)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j, Eq k)
- => Eq (a, b, c, d, e, f, g, h, i, j, k)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j, Eq k, Eq l)
- => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j, Eq k, Eq l, Eq m)
- => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n)
- => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
- Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o)
- => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-
-instance (Eq a) => Eq [a] where
- {-# SPECIALISE instance Eq [[Char]] #-}
- {-# SPECIALISE instance Eq [Char] #-}
- {-# SPECIALISE instance Eq [Int] #-}
- [] == [] = True
- (x:xs) == (y:ys) = x == y && xs == ys
- _xs == _ys = False
-
-deriving instance Eq Bool
-deriving instance Eq Ordering
-deriving instance Eq Word
-
-instance Eq Char where
- (C# c1) == (C# c2) = isTrue# (c1 `eqChar#` c2)
- (C# c1) /= (C# c2) = isTrue# (c1 `neChar#` c2)
-
-instance Eq Float where
- (F# x) == (F# y) = isTrue# (x `eqFloat#` y)
-
-instance Eq Double where
- (D# x) == (D# y) = isTrue# (x ==## y)
-
-instance Eq Int where
- (==) = eqInt
- (/=) = neInt
-
-{-# INLINE eqInt #-}
-{-# INLINE neInt #-}
-eqInt, neInt :: Int -> Int -> Bool
-(I# x) `eqInt` (I# y) = isTrue# (x ==# y)
-(I# x) `neInt` (I# y) = isTrue# (x /=# y)
-
--- | The 'Ord' class is used for totally ordered datatypes.
---
--- Instances of 'Ord' can be derived for any user-defined
--- datatype whose constituent types are in 'Ord'. The declared order
--- of the constructors in the data declaration determines the ordering
--- in derived 'Ord' instances. The 'Ordering' datatype allows a single
--- comparison to determine the precise ordering of two objects.
---
--- Minimal complete definition: either 'compare' or '<='.
--- Using 'compare' can be more efficient for complex types.
---
-class (Eq a) => Ord a where
- compare :: a -> a -> Ordering
- (<), (<=), (>), (>=) :: a -> a -> Bool
- max, min :: a -> a -> a
-
- compare x y = if x == y then EQ
- -- NB: must be '<=' not '<' to validate the
- -- above claim about the minimal things that
- -- can be defined for an instance of Ord:
- else if x <= y then LT
- else GT
-
- x < y = case compare x y of { LT -> True; _ -> False }
- x <= y = case compare x y of { GT -> False; _ -> True }
- x > y = case compare x y of { GT -> True; _ -> False }
- x >= y = case compare x y of { LT -> False; _ -> True }
-
- -- These two default methods use '<=' rather than 'compare'
- -- because the latter is often more expensive
- max x y = if x <= y then y else x
- min x y = if x <= y then x else y
- {-# MINIMAL compare | (<=) #-}
-
-deriving instance Ord ()
-deriving instance (Ord a, Ord b) => Ord (a, b)
-deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
-deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f)
- => Ord (a, b, c, d, e, f)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g)
- => Ord (a, b, c, d, e, f, g)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h)
- => Ord (a, b, c, d, e, f, g, h)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i)
- => Ord (a, b, c, d, e, f, g, h, i)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j)
- => Ord (a, b, c, d, e, f, g, h, i, j)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j, Ord k)
- => Ord (a, b, c, d, e, f, g, h, i, j, k)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j, Ord k, Ord l)
- => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j, Ord k, Ord l, Ord m)
- => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n)
- => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
- Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o)
- => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-
-instance (Ord a) => Ord [a] where
- {-# SPECIALISE instance Ord [[Char]] #-}
- {-# SPECIALISE instance Ord [Char] #-}
- {-# SPECIALISE instance Ord [Int] #-}
- compare [] [] = EQ
- compare [] (_:_) = LT
- compare (_:_) [] = GT
- compare (x:xs) (y:ys) = case compare x y of
- EQ -> compare xs ys
- other -> other
-
-deriving instance Ord Bool
-deriving instance Ord Ordering
-deriving instance Ord Word
-
--- We don't use deriving for Ord Char, because for Ord the derived
--- instance defines only compare, which takes two primops. Then
--- '>' uses compare, and therefore takes two primops instead of one.
-instance Ord Char where
- (C# c1) > (C# c2) = isTrue# (c1 `gtChar#` c2)
- (C# c1) >= (C# c2) = isTrue# (c1 `geChar#` c2)
- (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2)
- (C# c1) < (C# c2) = isTrue# (c1 `ltChar#` c2)
-
-instance Ord Float where
- (F# x) `compare` (F# y)
- = if isTrue# (x `ltFloat#` y) then LT
- else if isTrue# (x `eqFloat#` y) then EQ
- else GT
-
- (F# x) < (F# y) = isTrue# (x `ltFloat#` y)
- (F# x) <= (F# y) = isTrue# (x `leFloat#` y)
- (F# x) >= (F# y) = isTrue# (x `geFloat#` y)
- (F# x) > (F# y) = isTrue# (x `gtFloat#` y)
-
-instance Ord Double where
- (D# x) `compare` (D# y)
- = if isTrue# (x <## y) then LT
- else if isTrue# (x ==## y) then EQ
- else GT
-
- (D# x) < (D# y) = isTrue# (x <## y)
- (D# x) <= (D# y) = isTrue# (x <=## y)
- (D# x) >= (D# y) = isTrue# (x >=## y)
- (D# x) > (D# y) = isTrue# (x >## y)
-
-instance Ord Int where
- compare = compareInt
- (<) = ltInt
- (<=) = leInt
- (>=) = geInt
- (>) = gtInt
-
-{-# INLINE gtInt #-}
-{-# INLINE geInt #-}
-{-# INLINE ltInt #-}
-{-# INLINE leInt #-}
-gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool
-(I# x) `gtInt` (I# y) = isTrue# (x ># y)
-(I# x) `geInt` (I# y) = isTrue# (x >=# y)
-(I# x) `ltInt` (I# y) = isTrue# (x <# y)
-(I# x) `leInt` (I# y) = isTrue# (x <=# y)
-
-compareInt :: Int -> Int -> Ordering
-(I# x#) `compareInt` (I# y#) = compareInt# x# y#
-
-compareInt# :: Int# -> Int# -> Ordering
-compareInt# x# y#
- | isTrue# (x# <# y#) = LT
- | isTrue# (x# ==# y#) = EQ
- | True = GT
-
--- OK, so they're technically not part of a class...:
-
--- Boolean functions
-
--- | Boolean \"and\"
-(&&) :: Bool -> Bool -> Bool
-True && x = x
-False && _ = False
-
--- | Boolean \"or\"
-(||) :: Bool -> Bool -> Bool
-True || _ = True
-False || x = x
-
--- | Boolean \"not\"
-not :: Bool -> Bool
-not True = False
-not False = True
-
-
-------------------------------------------------------------------------
--- These don't really belong here, but we don't have a better place to
--- put them
-
-divInt# :: Int# -> Int# -> Int#
-x# `divInt#` y#
- -- Be careful NOT to overflow if we do any additional arithmetic
- -- on the arguments... the following previous version of this
- -- code has problems with overflow:
--- | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y#
--- | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y#
- = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
- else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
- else x# `quotInt#` y#
-
-modInt# :: Int# -> Int# -> Int#
-x# `modInt#` y#
- = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) ||
- isTrue# (x# <# 0#) && isTrue# (y# ># 0#)
- then if isTrue# (r# /=# 0#) then r# +# y# else 0#
- else r#
- where
- !r# = x# `remInt#` y#
+{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns,
+ KindSignatures, DataKinds, ConstraintKinds,
+ MultiParamTypeClasses, FunctionalDependencies #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# 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
+
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE UndecidableSuperClasses #-}
+{-# LANGUAGE ConstraintKinds #-}
+
+{-# OPTIONS_HADDOCK not-home #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Classes
+-- Copyright : (c) The University of Glasgow, 1992-2002
+-- License : see libraries/base/LICENSE
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Stability : internal
+-- Portability : non-portable (GHC extensions)
+--
+-- Basic classes.
+-- Do not import this module directly. It is an GHC internal only
+-- module. Some of its contents are instead available from @Prelude@
+-- and @GHC.Int@.
+--
+-----------------------------------------------------------------------------
+
+module GHC.Classes(
+ -- * Implicit parameters
+ IP(..),
+
+ -- * Equality and ordering
+ -- | Do not import these classes from this module. Import them
+ -- from @Prelude@ instead.
+ Eq(..),
+ Ord(..),
+ -- ** Monomorphic equality operators
+ -- $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
+ -- | Do not import these functions from this module. Import them
+ -- from @Prelude@ instead.
+ (&&), (||), not,
+
+ -- * Integer arithmetic
+ divInt#, divInt8#, divInt16#, divInt32#,
+ modInt#, modInt8#, modInt16#, modInt32#,
+ divModInt#, divModInt8#, divModInt16#, divModInt32#,
+
+ -- * Constraint tuples
+ CUnit,
+ CSolo,
+ CTuple0,
+ CTuple1,
+ CTuple2,
+ CTuple3,
+ CTuple4,
+ CTuple5,
+ CTuple6,
+ CTuple7,
+ CTuple8,
+ CTuple9,
+ CTuple10,
+ CTuple11,
+ CTuple12,
+ CTuple13,
+ CTuple14,
+ CTuple15,
+ CTuple16,
+ CTuple17,
+ CTuple18,
+ CTuple19,
+ CTuple20,
+ CTuple21,
+ CTuple22,
+ CTuple23,
+ CTuple24,
+ CTuple25,
+ CTuple26,
+ CTuple27,
+ CTuple28,
+ CTuple29,
+ CTuple30,
+ CTuple31,
+ CTuple32,
+ CTuple33,
+ CTuple34,
+ CTuple35,
+ CTuple36,
+ CTuple37,
+ CTuple38,
+ CTuple39,
+ CTuple40,
+ CTuple41,
+ CTuple42,
+ CTuple43,
+ CTuple44,
+ CTuple45,
+ CTuple46,
+ CTuple47,
+ CTuple48,
+ CTuple49,
+ CTuple50,
+ CTuple51,
+ CTuple52,
+ CTuple53,
+ CTuple54,
+ CTuple55,
+ CTuple56,
+ CTuple57,
+ CTuple58,
+ CTuple59,
+ CTuple60,
+ CTuple61,
+ CTuple62,
+ CTuple63,
+ CTuple64,
+ ) where
+
+-- GHC.Magic is used in some derived instances
+import GHC.Magic ()
+import GHC.Prim
+import GHC.Tuple
+import GHC.CString (unpackCString#)
+import GHC.Types
+
+infix 4 ==, /=, <, <=, >=, >
+infixr 3 &&
+infixr 2 ||
+
+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
+-- instances of 'Eq'.
+--
+-- The Haskell Report defines no laws for 'Eq'. However, instances are
+-- encouraged to follow these properties:
+--
+-- [__Reflexivity__]: @x == x@ = 'True'
+-- [__Symmetry__]: @x == y@ = @y == x@
+-- [__Transitivity__]: if @x == y && y == z@ = 'True', then @x == z@ = 'True'
+-- [__Extensionality__]: if @x == y@ = 'True' and @f@ is a function
+-- whose return type is an instance of 'Eq', then @f x == f y@ = 'True'
+-- [__Negation__]: @x /= y@ = @not (x == y)@
+class Eq a where
+ (==), (/=) :: a -> a -> Bool
+
+ {-# INLINE (/=) #-}
+ {-# INLINE (==) #-}
+ x /= y = not (x == y)
+ x == y = not (x /= y)
+ {-# MINIMAL (==) | (/=) #-}
+
+deriving instance Eq ()
+deriving instance Eq a => Eq (Solo a)
+deriving instance (Eq a, Eq b) => Eq (a, b)
+deriving instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
+deriving instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f)
+ => Eq (a, b, c, d, e, f)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g)
+ => Eq (a, b, c, d, e, f, g)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h)
+ => Eq (a, b, c, d, e, f, g, h)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i)
+ => Eq (a, b, c, d, e, f, g, h, i)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j)
+ => Eq (a, b, c, d, e, f, g, h, i, j)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j, Eq k)
+ => Eq (a, b, c, d, e, f, g, h, i, j, k)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j, Eq k, Eq l)
+ => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j, Eq k, Eq l, Eq m)
+ => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n)
+ => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
+ Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o)
+ => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+
+instance (Eq a) => Eq [a] where
+ {-# SPECIALISE instance Eq [[Char]] #-}
+ {-# SPECIALISE instance Eq [Char] #-}
+ {-# SPECIALISE instance Eq [Int] #-}
+ [] == [] = True
+ (x:xs) == (y:ys) = x == y && xs == ys
+ _xs == _ys = False
+
+deriving instance Eq Module
+
+instance Eq TrName where
+ TrNameS a == TrNameS b = isTrue# (a `eqAddr#` b)
+ a == b = toString a == toString b
+ where
+ toString (TrNameS s) = unpackCString# s
+ toString (TrNameD s) = s
+
+deriving instance Eq Bool
+deriving instance Eq Ordering
+
+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
+ (==) = 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)
+
+-- | Note that due to the presence of @NaN@, `Float`'s 'Eq' instance does not
+-- satisfy reflexivity.
+--
+-- >>> 0/0 == (0/0 :: Float)
+-- False
+--
+-- Also note that `Float`'s 'Eq' instance does not satisfy extensionality:
+--
+-- >>> 0 == (-0 :: Float)
+-- True
+-- >>> recip 0 == recip (-0 :: Float)
+-- False
+instance Eq Float where
+ (==) = 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)
+
+-- | Note that due to the presence of @NaN@, `Double`'s 'Eq' instance does not
+-- satisfy reflexivity.
+--
+-- >>> 0/0 == (0/0 :: Double)
+-- False
+--
+-- Also note that `Double`'s 'Eq' instance does not satisfy substitutivity:
+--
+-- >>> 0 == (-0 :: Double)
+-- True
+-- >>> recip 0 == recip (-0 :: Double)
+-- False
+instance Eq Double where
+ (==) = 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
+
+-- 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)
+
+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
+
+
+-- | The 'Ord' class is used for totally ordered datatypes.
+--
+-- Instances of 'Ord' can be derived for any user-defined datatype whose
+-- constituent types are in 'Ord'. The declared order of the constructors in
+-- the data declaration determines the ordering in derived 'Ord' instances. The
+-- 'Ordering' datatype allows a single comparison to determine the precise
+-- ordering of two objects.
+--
+-- 'Ord', as defined by the Haskell report, implements a total order and has the
+-- following properties:
+--
+-- [__Comparability__]: @x <= y || y <= x@ = 'True'
+-- [__Transitivity__]: if @x <= y && y <= z@ = 'True', then @x <= z@ = 'True'
+-- [__Reflexivity__]: @x <= x@ = 'True'
+-- [__Antisymmetry__]: if @x <= y && y <= x@ = 'True', then @x == y@ = 'True'
+--
+-- The following operator interactions are expected to hold:
+--
+-- 1. @x >= y@ = @y <= x@
+-- 2. @x < y@ = @x <= y && x /= y@
+-- 3. @x > y@ = @y < x@
+-- 4. @x < y@ = @compare x y == LT@
+-- 5. @x > y@ = @compare x y == GT@
+-- 6. @x == y@ = @compare x y == EQ@
+-- 7. @min x y == if x <= y then x else y@ = 'True'
+-- 8. @max x y == if x >= y then x else y@ = 'True'
+--
+-- Note that (7.) and (8.) do /not/ require 'min' and 'max' to return either of
+-- their arguments. The result is merely required to /equal/ one of the
+-- arguments in terms of '(==)'. Users who expect a stronger guarantee are advised
+-- to write their own min and/or max functions.
+--
+-- The nuance of the above distinction is not always fully internalized by
+-- developers, and in the past (tracing back to the Haskell 1.4 Report) the
+-- specification for 'Ord' asserted the stronger property that @(min x y, max x
+-- y) = (x, y)@ or @(y, x)@, or in other words, that 'min' and 'max' /will/
+-- return one of their arguments, using argument order as the tie-breaker if
+-- the arguments are equal by comparison. A few list and
+-- 'Data.Foldable.Foldable' functions have behavior that is best understood
+-- with this assumption in mind: all variations of @minimumBy@ and @maximumBy@
+-- (which can't use 'min' and 'max' in their implementations) are written such
+-- that @minimumBy 'compare'@ and @maximumBy 'compare'@ are respectively
+-- equivalent to @minimum@ and @maximum@ (which do use 'min' and 'max') only if
+-- 'min' and 'max' adhere to this tie-breaking convention. Otherwise, if there
+-- are multiple least or largest elements in a container, @minimum@ and
+-- @maximum@ may not return the /same/ one that @minimumBy 'compare'@ and
+-- @maximumBy 'compare'@ do (though they should return something that is
+-- /equal/). (This is relevant for types with non-extensional equality, like
+-- 'Data.Semigroup.Arg', but also in cases where the precise reference held
+-- matters for memory-management reasons.) Unless there is a reason to deviate,
+-- it is less confusing for implementors of 'Ord' to respect this same
+-- convention (as the default definitions of 'min' and 'max' do).
+--
+-- Minimal complete definition: either 'compare' or '<='.
+-- Using 'compare' can be more efficient for complex types.
+--
+class (Eq a) => Ord a where
+ compare :: a -> a -> Ordering
+ (<), (<=), (>), (>=) :: a -> a -> Bool
+ max, min :: a -> a -> a
+
+ compare x y = if x == y then EQ
+ -- NB: must be '<=' not '<' to validate the
+ -- above claim about the minimal things that
+ -- can be defined for an instance of Ord:
+ else if x <= y then LT
+ else GT
+
+ x <= y = case compare x y of { GT -> False; _ -> True }
+ x >= y = y <= x
+ x > y = not (x <= y)
+ x < y = not (y <= x)
+
+
+ -- These two default methods use '<=' rather than 'compare'
+ -- because the latter is often more expensive
+ max x y = if x <= y then y else x
+ min x y = if x <= y then x else y
+ {-# MINIMAL compare | (<=) #-}
+
+deriving instance Ord ()
+deriving instance Ord a => Ord (Solo a)
+deriving instance (Ord a, Ord b) => Ord (a, b)
+deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
+deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f)
+ => Ord (a, b, c, d, e, f)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g)
+ => Ord (a, b, c, d, e, f, g)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h)
+ => Ord (a, b, c, d, e, f, g, h)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i)
+ => Ord (a, b, c, d, e, f, g, h, i)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j)
+ => Ord (a, b, c, d, e, f, g, h, i, j)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j, Ord k)
+ => Ord (a, b, c, d, e, f, g, h, i, j, k)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j, Ord k, Ord l)
+ => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j, Ord k, Ord l, Ord m)
+ => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n)
+ => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
+ Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o)
+ => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+
+instance (Ord a) => Ord [a] where
+ {-# SPECIALISE instance Ord [[Char]] #-}
+ {-# SPECIALISE instance Ord [Char] #-}
+ {-# SPECIALISE instance Ord [Int] #-}
+ compare [] [] = EQ
+ compare [] (_:_) = LT
+ compare (_:_) [] = GT
+ compare (x:xs) (y:ys) = case compare x y of
+ EQ -> compare xs ys
+ other -> other
+
+deriving instance Ord Bool
+deriving instance Ord Ordering
+
+-- We don't use deriving for Ord Char, because for Ord the derived
+-- instance defines only compare, which takes two primops. Then
+-- '>' uses compare, and therefore takes two primops instead of one.
+instance Ord Char where
+ (C# c1) > (C# c2) = isTrue# (c1 `gtChar#` c2)
+ (C# c1) >= (C# c2) = isTrue# (c1 `geChar#` c2)
+ (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2)
+ (C# c1) < (C# c2) = isTrue# (c1 `ltChar#` c2)
+
+-- | See @instance@ 'Ord' 'Double' for discussion of deviations from IEEE 754 standard.
+instance Ord Float where
+ (F# x) `compare` (F# y)
+ = if isTrue# (x `ltFloat#` y) then LT
+ else if isTrue# (x `eqFloat#` y) then EQ
+ else GT
+
+ (F# x) < (F# y) = isTrue# (x `ltFloat#` y)
+ (F# x) <= (F# y) = isTrue# (x `leFloat#` y)
+ (F# x) >= (F# y) = isTrue# (x `geFloat#` y)
+ (F# x) > (F# y) = isTrue# (x `gtFloat#` y)
+
+-- | IEEE 754 'Double'-precision type includes not only numbers, but also
+-- positive and negative infinities and a special element called @NaN@
+-- (which can be quiet or signal).
+--
+-- IEEE 754-2008, section 5.11 requires that if at least one of arguments of
+-- '<=', '<', '>', '>=' is @NaN@ then the result of the comparison is 'False',
+-- and @instance@ 'Ord' 'Double' complies with this requirement. This violates
+-- the reflexivity: both @NaN@ '<=' @NaN@ and @NaN@ '>=' @NaN@ are 'False'.
+--
+-- IEEE 754-2008, section 5.10 defines @totalOrder@ predicate. Unfortunately,
+-- 'compare' on 'Double's violates the IEEE standard and does not define a total order.
+-- More specifically, both 'compare' @NaN@ @x@ and 'compare' @x@ @NaN@ always return 'GT'.
+--
+-- Thus, users must be extremely cautious when using @instance@ 'Ord' 'Double'.
+-- For instance, one should avoid ordered containers with keys represented by 'Double',
+-- because data loss and corruption may happen. An IEEE-compliant 'compare' is available
+-- in @fp-ieee@ package as @TotallyOrdered@ newtype.
+--
+-- Moving further, the behaviour of 'min' and 'max' with regards to @NaN@ is
+-- also non-compliant. IEEE 754-2008, section 5.3.1 defines that quiet @NaN@
+-- should be treated as a missing data by @minNum@ and @maxNum@ functions,
+-- for example, @minNum(NaN, 1) = minNum(1, NaN) = 1@. Some languages such as Java
+-- deviate from the standard implementing @minNum(NaN, 1) = minNum(1, NaN) = NaN@.
+-- However, 'min' / 'max' in @base@ are even worse: 'min' @NaN@ 1 is 1, but 'min' 1 @NaN@
+-- is @NaN@.
+--
+-- IEEE 754-2008 compliant 'min' / 'max' can be found in @ieee754@ package under
+-- @minNum@ / @maxNum@ names. Implementations compliant with
+-- @minimumNumber@ / @maximumNumber@ from a newer
+-- [IEEE 754-2019](https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/),
+-- section 9.6 are available from @fp-ieee@ package.
+--
+instance Ord Double where
+ (D# x) `compare` (D# y)
+ = if isTrue# (x <## y) then LT
+ else if isTrue# (x ==## y) then EQ
+ else GT
+
+ (D# x) < (D# y) = isTrue# (x <## y)
+ (D# x) <= (D# y) = isTrue# (x <=## y)
+ (D# x) >= (D# y) = isTrue# (x >=## y)
+ (D# x) > (D# y) = isTrue# (x >## y)
+
+instance Ord Int where
+ compare = compareInt
+ (<) = ltInt
+ (<=) = leInt
+ (>=) = geInt
+ (>) = gtInt
+
+-- 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)
+(I# x) `ltInt` (I# y) = isTrue# (x <# y)
+(I# x) `leInt` (I# y) = isTrue# (x <=# y)
+
+-- See GHC.Classes#matching_overloaded_methods_in_rules
+{-# INLINE [1] compareInt #-}
+compareInt :: Int -> Int -> Ordering
+(I# x#) `compareInt` (I# y#) = compareInt# x# y#
+
+compareInt# :: Int# -> Int# -> Ordering
+compareInt# x# y#
+ | isTrue# (x# <# y#) = LT
+ | isTrue# (x# ==# y#) = EQ
+ | True = GT
+
+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)
+
+-- See GHC.Classes#matching_overloaded_methods_in_rules
+{-# INLINE [1] compareWord #-}
+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
+
+-- | Boolean \"and\", lazy in the second argument
+(&&) :: Bool -> Bool -> Bool
+True && x = x
+False && _ = False
+
+-- | Boolean \"or\", lazy in the second argument
+(||) :: Bool -> Bool -> Bool
+True || _ = True
+False || x = x
+
+-- | Boolean \"not\"
+not :: Bool -> Bool
+not True = False
+not False = True
+
+
+------------------------------------------------------------------------
+-- These don't really belong here, but we don't have a better place to
+-- put them
+
+-- These functions have built-in rules.
+{-# INLINE [0] divInt# #-}
+divInt# :: Int# -> Int# -> Int#
+x# `divInt#` y# = ((x# +# bias#) `quotInt#` y#) -# hard#
+ where
+ -- See Note [divInt# implementation]
+ !yn# = y# <# 0#
+ !c0# = (x# <# 0#) `andI#` (notI# yn#)
+ !c1# = (x# ># 0#) `andI#` yn#
+ !bias# = c0# -# c1#
+ !hard# = c0# `orI#` c1#
+
+{-# INLINE [0] divInt8# #-}
+divInt8# :: Int8# -> Int8# -> Int8#
+x# `divInt8#` y# = ((x# `plusInt8#` bias#) `quotInt8#` y#) `subInt8#` hard#
+ where
+ zero# = intToInt8# 0#
+ x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y)
+ x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y)
+ notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x))
+ -- See Note [divInt# implementation]
+ !yn# = intToInt8# (y# `ltInt8#` zero#)
+ !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#)
+ !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn#
+ !bias# = c0# `subInt8#` c1#
+ !hard# = c0# `orInt8#` c1#
+
+{-# INLINE [0] divInt16# #-}
+divInt16# :: Int16# -> Int16# -> Int16#
+x# `divInt16#` y# = ((x# `plusInt16#` bias#) `quotInt16#` y#) `subInt16#` hard#
+ where
+ zero# = intToInt16# 0#
+ x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y)
+ x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y)
+ notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x))
+ -- See Note [divInt# implementation]
+ !yn# = intToInt16# (y# `ltInt16#` zero#)
+ !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#)
+ !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn#
+ !bias# = c0# `subInt16#` c1#
+ !hard# = c0# `orInt16#` c1#
+
+{-# INLINE [0] divInt32# #-}
+divInt32# :: Int32# -> Int32# -> Int32#
+x# `divInt32#` y# = ((x# `plusInt32#` bias#) `quotInt32#` y#) `subInt32#` hard#
+ where
+ zero# = intToInt32# 0#
+ x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y)
+ x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y)
+ notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x))
+ -- See Note [divInt# implementation]
+ !yn# = intToInt32# (y# `ltInt32#` zero#)
+ !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#)
+ !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn#
+ !bias# = c0# `subInt32#` c1#
+ !hard# = c0# `orInt32#` c1#
+
+-- Note [divInt# implementation]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- divInt# (truncated toward zero) is implemented with quotInt# (truncated
+-- toward negative infinity). They differ when inputs x and y have different signs:
+-- - x `rem` y has the sign of x and (x `quot` y)*y + (x `rem` y) == x
+-- - x `mod` y has the sign of y and (x `div` y)*y + (x `mod` y) == x
+--
+-- So we bias the input and the result of quotInt as follows:
+--
+-- if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
+-- else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
+-- else x# `quotInt#` y#
+--
+-- However this leads to assembly code with lots of branches (#19636) while we
+-- would like simpler code that we could inline (#18067). So we use some
+-- branchless code instead as derived below:
+--
+-- if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
+-- else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
+-- else x# `quotInt#` y#
+--
+-- ===> { Give names to constants and always use them }
+--
+-- ((x# +# bias#) `quotInt#` y#) -# hard#
+-- where
+-- (bias#,hard#)
+-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) = (-1#, 1#)
+-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) = ( 1#, 1#)
+-- | otherwise = ( 0#, 0#)
+--
+-- ===> { Compute bias# and hard# independently using Bool# (0#,1#) }
+--
+-- ((x# +# bias#) `quotInt#` y#) -# hard#
+-- where
+-- c0# = (x# <# 0#) &&# (y# ># 0#)
+-- c1# = (x# ># 0#) &&# (y# <# 0#)
+-- bias# = c0# -# c1# -- both cases are mutually exclusive so we can subtract them
+-- hard# = c0# ||# c1# -- (we could add them too here but OR is slightly better)
+--
+-- ===> { Use yn# variable for "y# <# 0#" }
+--
+-- ((x# +# bias#) `quotInt#` y#) -# hard#
+-- where
+-- -- y# ==# 0# throws an exception so we don't need to consider it
+-- yn# = y# <# 0#
+-- c0# = (x# <# 0#) &&# (notI# yn#)
+-- c1# = (x# ># 0#) &&# yn#
+-- bias# = c0# -# c1#
+-- hard# = c0# ||# c1#
+--
+--
+-- Note that we need to be careful NOT to overflow if we do any additional
+-- arithmetic on the arguments... the following previous version of this code
+-- had problems with overflow:
+-- | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y#
+-- | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y#
+
+{-# INLINE [0] modInt# #-}
+modInt# :: Int# -> Int# -> Int#
+x# `modInt#` y# = r# +# k#
+ where
+ -- See Note [modInt# implementation]
+ !yn# = y# <# 0#
+ !c0# = (x# <# 0#) `andI#` (notI# yn#)
+ !c1# = (x# ># 0#) `andI#` yn#
+ !s# = 0# -# ((c0# `orI#` c1#) `andI#` (r# /=# 0#))
+ !k# = s# `andI#` y#
+ !r# = x# `remInt#` y#
+
+{-# INLINE [0] modInt8# #-}
+modInt8# :: Int8# -> Int8# -> Int8#
+x# `modInt8#` y# = r# `plusInt8#` k#
+ where
+ zero# = intToInt8# 0#
+ x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y)
+ x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y)
+ notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x))
+ -- See Note [modInt# implementation]
+ !yn# = intToInt8# (y# `ltInt8#` zero#)
+ !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#)
+ !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn#
+ !s# = zero# `subInt8#` ((c0# `orInt8#` c1#) `andInt8#` (intToInt8# (r# `neInt8#` zero#)))
+ !k# = s# `andInt8#` y#
+ !r# = x# `remInt8#` y#
+
+{-# INLINE [0] modInt16# #-}
+modInt16# :: Int16# -> Int16# -> Int16#
+x# `modInt16#` y# = r# `plusInt16#` k#
+ where
+ zero# = intToInt16# 0#
+ x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y)
+ x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y)
+ notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x))
+ -- See Note [modInt# implementation]
+ !yn# = intToInt16# (y# `ltInt16#` zero#)
+ !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#)
+ !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn#
+ !s# = zero# `subInt16#` ((c0# `orInt16#` c1#) `andInt16#` (intToInt16# (r# `neInt16#` zero#)))
+ !k# = s# `andInt16#` y#
+ !r# = x# `remInt16#` y#
+
+{-# INLINE [0] modInt32# #-}
+modInt32# :: Int32# -> Int32# -> Int32#
+x# `modInt32#` y# = r# `plusInt32#` k#
+ where
+ zero# = intToInt32# 0#
+ x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y)
+ x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y)
+ notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x))
+ -- See Note [modInt# implementation]
+ !yn# = intToInt32# (y# `ltInt32#` zero#)
+ !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#)
+ !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn#
+ !s# = zero# `subInt32#` ((c0# `orInt32#` c1#) `andInt32#` (intToInt32# (r# `neInt32#` zero#)))
+ !k# = s# `andInt32#` y#
+ !r# = x# `remInt32#` y#
+
+-- Note [modInt# implementation]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Similarly to divInt# (see Note [divInt# implementation]), we can derive the
+-- branchless implementation of modInt# as follows:
+--
+-- = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) ||
+-- isTrue# (x# <# 0#) && isTrue# (y# ># 0#)
+-- then if isTrue# (r# /=# 0#) then r# +# y# else 0#
+-- else r#
+-- where
+-- r# = x# `remInt#` y#
+--
+-- ===> { Introduce constant k# }
+--
+-- r# +# k#
+-- where
+-- k# = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) ||
+-- isTrue# (x# <# 0#) && isTrue# (y# ># 0#)
+-- then if isTrue# (r# /=# 0#) then y# else 0#
+-- else 0#
+-- r# = x# `remInt#` y#
+--
+-- ===> { Compute using Bool# }
+--
+-- r# +# k#
+-- where
+-- yn# = y# <# 0# -- we don't need to consider y# ==# 0#
+-- c0# = (x# <# 0#) &&# (notI# yn#)
+-- c1# = (x# ># 0#) &&# yn#
+-- k# = if isTrue# ((c0# ||# c1#) &&# (r# /=# 0#))
+-- then y#
+-- else 0#
+-- r# = x# `remInt#` y#
+--
+-- ===> { Select y# or 0# in branchless way }
+--
+-- r# +# k#
+-- where
+-- yn# = y# <# 0#
+-- c0# = (x# <# 0#) &&# (notI# yn#)
+-- c1# = (x# ># 0#) &&# yn#
+-- -- s# is either equal to:
+-- -- 0# (00..00b)
+-- -- -1# (11..11b)
+-- -- So we can AND s# with y#
+-- s# = 0# -# ((c0# ||# c1#) &&# (r# /=# 0#))
+-- k# = s# &&# y#
+-- r# = x# `remInt#` y#
+
+{-# INLINE [0] divModInt# #-}
+divModInt# :: Int# -> Int# -> (# Int#, Int# #)
+x# `divModInt#` y# = case (x# +# bias#) `quotRemInt#` y# of
+ (# q#, r# #) -> (# q# -# hard#, r# +# k# #)
+ where
+ -- See Note [divModInt# implementation]
+ !yn# = y# <# 0#
+ !c0# = (x# <# 0#) `andI#` (notI# yn#)
+ !c1# = (x# ># 0#) `andI#` yn#
+ !bias# = c0# -# c1#
+ !hard# = c0# `orI#` c1#
+ !s# = 0# -# hard#
+ !k# = (s# `andI#` y#) -# bias#
+
+{-# INLINE [0] divModInt8# #-}
+divModInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
+x# `divModInt8#` y# = case (x# `plusInt8#` bias#) `quotRemInt8#` y# of
+ (# q#, r# #) -> (# q# `subInt8#` hard#, r# `plusInt8#` k# #)
+ where
+ zero# = intToInt8# 0#
+ x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y)
+ x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y)
+ notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x))
+ -- See Note [divModInt# implementation]
+ !yn# = intToInt8# (y# `ltInt8#` zero#)
+ !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#)
+ !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn#
+ !bias# = c0# `subInt8#` c1#
+ !hard# = c0# `orInt8#` c1#
+ !s# = zero# `subInt8#` hard#
+ !k# = (s# `andInt8#` y#) `subInt8#` bias#
+
+{-# INLINE [0] divModInt16# #-}
+divModInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
+x# `divModInt16#` y# = case (x# `plusInt16#` bias#) `quotRemInt16#` y# of
+ (# q#, r# #) -> (# q# `subInt16#` hard#, r# `plusInt16#` k# #)
+ where
+ zero# = intToInt16# 0#
+ x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y)
+ x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y)
+ notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x))
+ -- See Note [divModInt# implementation]
+ !yn# = intToInt16# (y# `ltInt16#` zero#)
+ !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#)
+ !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn#
+ !bias# = c0# `subInt16#` c1#
+ !hard# = c0# `orInt16#` c1#
+ !s# = zero# `subInt16#` hard#
+ !k# = (s# `andInt16#` y#) `subInt16#` bias#
+
+{-# INLINE [0] divModInt32# #-}
+divModInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
+x# `divModInt32#` y# = case (x# `plusInt32#` bias#) `quotRemInt32#` y# of
+ (# q#, r# #) -> (# q# `subInt32#` hard#, r# `plusInt32#` k# #)
+ where
+ zero# = intToInt32# 0#
+ x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y)
+ x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y)
+ notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x))
+ -- See Note [divModInt# implementation]
+ !yn# = intToInt32# (y# `ltInt32#` zero#)
+ !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#)
+ !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn#
+ !bias# = c0# `subInt32#` c1#
+ !hard# = c0# `orInt32#` c1#
+ !s# = zero# `subInt32#` hard#
+ !k# = (s# `andInt32#` y#) `subInt32#` bias#
+
+-- Note [divModInt# implementation]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- divModInt# is written by deriving the following code similarly to divInt# and
+-- modInt# (see Note [divInt# implementation] and Note [modInt#
+-- implementation]).
+--
+-- x# `divModInt#` y#
+-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) =
+-- case (x# -# 1#) `quotRemInt#` y# of
+-- (# q, r #) -> (# q -# 1#, r +# y# +# 1# #)
+-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) =
+-- case (x# +# 1#) `quotRemInt#` y# of
+-- (# q, r #) -> (# q -# 1#, r +# y# -# 1# #)
+-- | otherwise =
+-- x# `quotRemInt#` y#
+--
+-- ===> { Introduce constants }
+--
+-- case (x# +# bias#) `quotRemInt#` y# of
+-- (# q#, r# #) -> (# q# -# hard#, r# +# k# #)
+-- where
+-- (bias#,hard#,k#)
+-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) = (-1#, 1#, y#+1#)
+-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) = ( 1#, 1#, y#-1#)
+-- | otherwise = ( 0#, 0#, 0#-0#)
+--
+-- ===> { Compute using Bool# }
+--
+-- case (x# +# bias#) `quotRemInt#` y# of
+-- (# q#, r# #) -> (# q# -# hard#, r# +# k# #)
+-- where
+-- yn# = y# <# 0#
+-- c0# = (x# <# 0#) `andI#` (notI# yn#)
+-- c1# = (x# ># 0#) `andI#` yn#
+-- bias# = c0# -# c1#
+-- hard# = c0# `orI#` c1#
+-- s# = 0# -# hard#
+-- k# = (s# `andI#` y#) -# bias#
+--
+
+{- *************************************************************
+* *
+* Constraint tuples *
+* *
+************************************************************* -}
+
+type CTuple0 = (() :: Constraint)
+type CTuple1 = CSolo
+
+class CUnit
+class a => CSolo a
+class (c1, c2) => CTuple2 c1 c2
+class (c1, c2, c3) => CTuple3 c1 c2 c3
+class (c1, c2, c3, c4) => CTuple4 c1 c2 c3 c4
+class (c1, c2, c3, c4, c5) => CTuple5 c1 c2 c3 c4 c5
+class (c1, c2, c3, c4, c5, c6) => CTuple6 c1 c2 c3 c4 c5 c6
+class (c1, c2, c3, c4, c5, c6, c7) => CTuple7 c1 c2 c3 c4 c5 c6 c7
+class (c1, c2, c3, c4, c5, c6, c7, c8) => CTuple8 c1 c2 c3 c4 c5 c6 c7 c8
+class (c1, c2, c3, c4, c5, c6, c7, c8, c9)
+ => CTuple9 c1 c2 c3 c4 c5 c6 c7 c8 c9
+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
+ => CTuple10 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10
+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)
+ => CTuple11 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11
+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)
+ => CTuple12 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)
+ => CTuple13 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)
+ => CTuple14 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)
+ => CTuple15 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)
+ => CTuple16 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)
+ => CTuple17 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)
+ => CTuple18 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)
+ => CTuple19 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)
+ => CTuple20 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)
+ => CTuple21 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)
+ => CTuple22 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)
+ => CTuple23 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)
+ => CTuple24 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)
+ => CTuple25 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)
+ => CTuple26 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)
+ => CTuple27 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)
+ => CTuple28 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)
+ => CTuple29 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)
+ => CTuple30 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)
+ => CTuple31 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)
+ => CTuple32 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)
+ => CTuple33 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)
+ => CTuple34 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)
+ => CTuple35 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)
+ => CTuple36 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)
+ => CTuple37 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)
+ => CTuple38 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)
+ => CTuple39 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)
+ => CTuple40 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)
+ => CTuple41 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)
+ => CTuple42 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)
+ => CTuple43 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)
+ => CTuple44 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)
+ => CTuple45 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)
+ => CTuple46 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)
+ => CTuple47 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)
+ => CTuple48 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)
+ => CTuple49 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)
+ => CTuple50 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)
+ => CTuple51 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)
+ => CTuple52 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)
+ => CTuple53 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)
+ => CTuple54 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)
+ => CTuple55 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)
+ => CTuple56 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)
+ => CTuple57 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)
+ => CTuple58 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)
+ => CTuple59 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)
+ => CTuple60 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)
+ => CTuple61 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)
+ => CTuple62 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
+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, c63)
+ => CTuple63 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 c63
+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, c63, c64)
+ => CTuple64 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 c63 c64
+
+instance CUnit
+instance a => CSolo a
+instance (c1, c2) => CTuple2 c1 c2
+instance (c1, c2, c3) => CTuple3 c1 c2 c3
+instance (c1, c2, c3, c4) => CTuple4 c1 c2 c3 c4
+instance (c1, c2, c3, c4, c5) => CTuple5 c1 c2 c3 c4 c5
+instance (c1, c2, c3, c4, c5, c6) => CTuple6 c1 c2 c3 c4 c5 c6
+instance (c1, c2, c3, c4, c5, c6, c7) => CTuple7 c1 c2 c3 c4 c5 c6 c7
+instance (c1, c2, c3, c4, c5, c6, c7, c8) => CTuple8 c1 c2 c3 c4 c5 c6 c7 c8
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9)
+ => CTuple9 c1 c2 c3 c4 c5 c6 c7 c8 c9
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
+ => CTuple10 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)
+ => CTuple11 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)
+ => CTuple12 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13)
+ => CTuple13 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14)
+ => CTuple14 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15)
+ => CTuple15 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16)
+ => CTuple16 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17)
+ => CTuple17 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17,c18)
+ => CTuple18 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19)
+ => CTuple19 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19, c20)
+ => CTuple20 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19 c20
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19, c20, c21)
+ => CTuple21 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19 c20 c21
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19, c20, c21, c22)
+ => CTuple22 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19 c20 c21 c22
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19, c20, c21, c22, c23)
+ => CTuple23 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19 c20 c21 c22 c23
+instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,
+ c17, c18, c19, c20, c21, c22, c23, c24)
+ => CTuple24 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18
+ c19 c20 c21 c22 c23 c24
+instance (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)
+ => CTuple25 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
+instance (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)
+ => CTuple26 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
+instance (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)
+ => CTuple27 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
+instance (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)
+ => CTuple28 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
+instance (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)
+ => CTuple29 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
+instance (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)
+ => CTuple30 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
+instance (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)
+ => CTuple31 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
+instance (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)
+ => CTuple32 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
+instance (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)
+ => CTuple33 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
+instance (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)
+ => CTuple34 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
+instance (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)
+ => CTuple35 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
+instance (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)
+ => CTuple36 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
+instance (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)
+ => CTuple37 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
+instance (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)
+ => CTuple38 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
+instance (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)
+ => CTuple39 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
+instance (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)
+ => CTuple40 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
+instance (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)
+ => CTuple41 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
+instance (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)
+ => CTuple42 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
+instance (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)
+ => CTuple43 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
+instance (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)
+ => CTuple44 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
+instance (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)
+ => CTuple45 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
+instance (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)
+ => CTuple46 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
+instance (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)
+ => CTuple47 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
+instance (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)
+ => CTuple48 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
+instance (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)
+ => CTuple49 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
+instance (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)
+ => CTuple50 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
+instance (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)
+ => CTuple51 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
+instance (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)
+ => CTuple52 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
+instance (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)
+ => CTuple53 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
+instance (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)
+ => CTuple54 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
+instance (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)
+ => CTuple55 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
+instance (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)
+ => CTuple56 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
+instance (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)
+ => CTuple57 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
+instance (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)
+ => CTuple58 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
+instance (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)
+ => CTuple59 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
+instance (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)
+ => CTuple60 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
+instance (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)
+ => CTuple61 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
+instance (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)
+ => CTuple62 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
+instance (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, c63)
+ => CTuple63 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 c63
+instance (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, c63, c64)
+ => CTuple64 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 c63 c64
diff --git a/GHC/Debug.hs b/GHC/Debug.hs
--- a/GHC/Debug.hs
+++ b/GHC/Debug.hs
@@ -1,10 +1,15 @@
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes #-}
+-- | Users should not import this module. It is GHC internal only.
+
module GHC.Debug ( debugLn, debugErrLn ) where
import GHC.Prim
import GHC.Types
+
+-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base
+-- (This module uses the empty tuple.)
import GHC.Tuple ()
debugLn :: [Char] -> IO ()
diff --git a/GHC/IntWord64.hs b/GHC/IntWord64.hs
deleted file mode 100644
--- a/GHC/IntWord64.hs
+++ /dev/null
@@ -1,71 +0,0 @@
-{-# LANGUAGE CPP, MagicHash, NoImplicitPrelude, UnliftedFFITypes #-}
-{-# OPTIONS_HADDOCK hide #-}
------------------------------------------------------------------------------
--- |
--- Module : GHC.IntWord64
--- Copyright : (c) The University of Glasgow, 1997-2008
--- License : see libraries/ghc-prim/LICENSE
---
--- Maintainer : cvs-ghc@haskell.org
--- Stability : internal
--- Portability : non-portable (GHC Extensions)
---
--- Primitive operations on Int64# and Word64# on platforms where
--- WORD_SIZE_IN_BITS < 64.
---
------------------------------------------------------------------------------
-
-#include "MachDeps.h"
-
-module GHC.IntWord64 (
-#if WORD_SIZE_IN_BITS < 64
- Int64#, Word64#, module GHC.IntWord64
-#endif
- ) where
-
-#if WORD_SIZE_IN_BITS < 64
-import GHC.Prim
-
-foreign import ccall unsafe "hs_eqWord64" eqWord64# :: Word64# -> Word64# -> Int#
-foreign import ccall unsafe "hs_neWord64" neWord64# :: Word64# -> Word64# -> Int#
-foreign import ccall unsafe "hs_ltWord64" ltWord64# :: Word64# -> Word64# -> Int#
-foreign import ccall unsafe "hs_leWord64" leWord64# :: Word64# -> Word64# -> Int#
-foreign import ccall unsafe "hs_gtWord64" gtWord64# :: Word64# -> Word64# -> Int#
-foreign import ccall unsafe "hs_geWord64" geWord64# :: Word64# -> Word64# -> Int#
-
-foreign import ccall unsafe "hs_eqInt64" eqInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_neInt64" neInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_ltInt64" ltInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_leInt64" leInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_gtInt64" gtInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_geInt64" geInt64# :: Int64# -> Int64# -> Int#
-foreign import ccall unsafe "hs_quotInt64" quotInt64# :: Int64# -> Int64# -> Int64#
-foreign import ccall unsafe "hs_remInt64" remInt64# :: Int64# -> Int64# -> Int64#
-
-foreign import ccall unsafe "hs_plusInt64" plusInt64# :: Int64# -> Int64# -> Int64#
-foreign import ccall unsafe "hs_minusInt64" minusInt64# :: Int64# -> Int64# -> Int64#
-foreign import ccall unsafe "hs_timesInt64" timesInt64# :: Int64# -> Int64# -> Int64#
-foreign import ccall unsafe "hs_negateInt64" negateInt64# :: Int64# -> Int64#
-foreign import ccall unsafe "hs_quotWord64" quotWord64# :: Word64# -> Word64# -> Word64#
-foreign import ccall unsafe "hs_remWord64" remWord64# :: Word64# -> Word64# -> Word64#
-
-foreign import ccall unsafe "hs_and64" and64# :: Word64# -> Word64# -> Word64#
-foreign import ccall unsafe "hs_or64" or64# :: Word64# -> Word64# -> Word64#
-foreign import ccall unsafe "hs_xor64" xor64# :: Word64# -> Word64# -> Word64#
-foreign import ccall unsafe "hs_not64" not64# :: Word64# -> Word64#
-
-foreign import ccall unsafe "hs_uncheckedShiftL64" uncheckedShiftL64# :: Word64# -> Int# -> Word64#
-foreign import ccall unsafe "hs_uncheckedShiftRL64" uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
-foreign import ccall unsafe "hs_uncheckedIShiftL64" uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
-foreign import ccall unsafe "hs_uncheckedIShiftRA64" uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
-foreign import ccall unsafe "hs_uncheckedIShiftRL64" uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
-
-foreign import ccall unsafe "hs_int64ToWord64" int64ToWord64# :: Int64# -> Word64#
-foreign import ccall unsafe "hs_word64ToInt64" word64ToInt64# :: Word64# -> Int64#
-foreign import ccall unsafe "hs_intToInt64" intToInt64# :: Int# -> Int64#
-foreign import ccall unsafe "hs_int64ToInt" int64ToInt# :: Int64# -> Int#
-foreign import ccall unsafe "hs_wordToWord64" wordToWord64# :: Word# -> Word64#
-foreign import ccall unsafe "hs_word64ToWord" word64ToWord# :: Word64# -> Word#
-
-#endif
-
diff --git a/GHC/Magic.hs b/GHC/Magic.hs
--- a/GHC/Magic.hs
+++ b/GHC/Magic.hs
@@ -1,12 +1,19 @@
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE StandaloneKindSignatures #-}
+{-# OPTIONS_HADDOCK print-explicit-runtime-reps #-}
+
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Magic
-- Copyright : (c) The University of Glasgow 2009
-- License : see libraries/ghc-prim/LICENSE
--
--- Maintainer : cvs-ghc@haskell.org
+-- Maintainer : ghc-devs@haskell.org
-- Stability : internal
-- Portability : non-portable (GHC Extensions)
--
@@ -17,18 +24,28 @@
--
-----------------------------------------------------------------------------
-module GHC.Magic ( inline, lazy, oneShot ) where
+module GHC.Magic ( inline, noinline, lazy, oneShot, runRW#, DataToTag(..) ) where
--- | The call @inline f@ arranges that 'f' is inlined, regardless of
+--------------------------------------------------
+-- See Note [magicIds] in GHC.Types.Id.Make
+--------------------------------------------------
+
+-- Here import TYPE explicitly from GHC.Types and not from GHC.Prim. This is
+-- because TYPE is not exported by the source Haskell module generated by
+-- genprimops which Haddock will typecheck (#15935).
+import GHC.Prim (State#, realWorld#, RealWorld, Int#)
+import GHC.Types (RuntimeRep(BoxedRep), TYPE, Levity, Constraint)
+
+-- | The call @inline f@ arranges that @f@ is inlined, regardless of
-- its size. More precisely, the call @inline f@ rewrites to the
-- right-hand side of @f@'s definition. This allows the programmer to
-- control inlining from a particular call site rather than the
--- definition site of the function (c.f. 'INLINE' pragmas).
+-- definition site of the function (c.f. @INLINE@ pragmas).
--
-- This inlining occurs regardless of the argument to the call or the
-- size of @f@'s definition; it is unconditional. The main caveat is
-- that @f@'s definition must be visible to the compiler; it is
--- therefore recommended to mark the function with an 'INLINABLE'
+-- therefore recommended to mark the function with an @INLINABLE@
-- pragma at its definition so that GHC guarantees to record its
-- unfolding regardless of size.
--
@@ -38,8 +55,15 @@
inline :: a -> a
inline x = x
+-- | The call @noinline f@ arranges that @f@ will not be inlined.
+-- It is removed during CorePrep so that its use imposes no overhead
+-- (besides the fact that it blocks inlining.)
+noinline :: a -> a
+{-# NOINLINE noinline #-} -- noinline is inlined manually in CorePrep
+noinline x = x
+
-- | The 'lazy' function restrains strictness analysis a little. The
--- call @lazy e@ means the same as 'e', but 'lazy' has a magical
+-- call @lazy e@ means the same as @e@, but 'lazy' has a magical
-- property so far as strictness analysis is concerned: it is lazy in
-- its first argument, even though its semantics is strict. After
-- strictness analysis has run, calls to 'lazy' are inlined to be the
@@ -52,14 +76,13 @@
-- > par :: a -> b -> b
-- > par x y = case (par# x) of _ -> lazy y
--
--- If 'lazy' were not lazy, 'par' would look strict in 'y' which
--- would defeat the whole purpose of 'par'.
---
--- Like 'seq', the argument of 'lazy' can have an unboxed type.
+-- If 'lazy' were not lazy, 'Control.Parallel.par' would look strict in
+-- @y@ which would defeat the whole purpose of 'Control.Parallel.par'.
lazy :: a -> a
+{-# NOINLINE lazy #-} -- lazy is inlined manually in CorePrep
lazy x = x
-- Implementation note: its strictness and unfolding are over-ridden
--- by the definition in MkId.lhs; in both cases to nothing at all.
+-- by the definition in GHC.Types.Id.Make; in both cases to nothing at all.
-- That way, 'lazy' does not get inlined, and the strictness analyser
-- sees it as lazy. Then the worker/wrapper phase inlines it.
-- Result: happiness
@@ -69,7 +92,48 @@
-- 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.
-oneShot :: (a -> b) -> (a -> b)
+--
+-- 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 representation-polymorphic: the type variables may refer to lifted
+-- or unlifted types.
+oneShot :: forall (q :: RuntimeRep) (r :: RuntimeRep)
+ (a :: TYPE q) (b :: TYPE r).
+ (a -> b) -> a -> b
oneShot f = f
--- Implementation note: This is wired in in MkId.lhs, so the code here is
+-- Implementation note: This is wired in in GHC.Types.Id.Make, so the code here is
-- mostly there to have a place for the documentation.
+
+-- | Apply a function to a @'State#' 'RealWorld'@ token. When manually applying
+-- a function to `realWorld#`, it is necessary to use @NOINLINE@ to prevent
+-- semantically undesirable floating. `runRW#` is inlined, but only very late
+-- in compilation after all floating is complete.
+
+-- 'runRW#' is levity-polymorphic: the result may have a lifted or
+-- unlifted type.
+
+runRW# :: forall (r :: RuntimeRep) (o :: TYPE r).
+ (State# RealWorld -> o) -> o
+-- See Note [runRW magic] in GHC.CoreToStg.Prep.
+{-# NOINLINE runRW# #-} -- runRW# is inlined manually in CorePrep
+runRW# m = m realWorld#
+
+-- | @'dataToTag#'@ evaluates its argument and returns the index
+-- (starting at zero) of the constructor used to produce that
+-- argument. Any algebraic data type with all of its constructors
+-- in scope may be used with @dataToTag#@.
+--
+-- >>> dataToTag# (Left ())
+-- 0#
+-- >>> dataToTag# (Right undefined)
+-- 1#
+type DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint
+-- See Note [DataToTag overview] in GHC.Tc.Instance.Class.
+--
+-- Ignoring DatatypeContexts, any generated DataToTag instance is
+-- equivalent to a function the user could have written themselves.
+-- So it does not get its own Unsafe module, unlike WithDict.
+class DataToTag a where
+ dataToTag# :: a -> Int#
diff --git a/GHC/Magic/Dict.hs b/GHC/Magic/Dict.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Magic/Dict.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE AllowAmbiguousTypes #-} -- See Note [withDict has an ambiguous type]
+{-# LANGUAGE Unsafe #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Magic.Dict
+-- Copyright : (c) The University of Glasgow 2009
+-- License : see libraries/ghc-prim/LICENSE
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Stability : internal
+-- Portability : non-portable (GHC Extensions)
+--
+-- Defines the 'withDict' function. For more information, see
+-- @Note [withDict]@ in "GHC.Tc.Instance.Class" in GHC.
+-- The definition of 'withDict' is located in a separate module from
+-- "GHC.Magic" because 'withDict' is @Unsafe@ (it threatens type class
+-- coherence) while "GHC.Magic" is @Trustworthy@.
+--
+-- Use "GHC.Exts" from the @base@ package instead of importing this
+-- module directly.
+--
+-----------------------------------------------------------------------------
+
+module GHC.Magic.Dict (
+ WithDict( withDict )
+ ) where
+
+import GHC.Types (RuntimeRep, TYPE)
+
+-- | The constraint @'WithDict' cls meth@ can be solved when evidence for
+-- the constraint @cls@ can be provided in the form of a dictionary of
+-- type @meth@. This requires @cls@ to be a class constraint whose single
+-- method has type @meth@.
+--
+-- For more (important) details on how this works, see
+-- @Note [withDict]@ in "GHC.Tc.Instance.Class" in GHC.
+--
+-- @since 0.9.0
+class WithDict cls meth where
+ -- @'withDict' d f@ provides a way to call a type-class–overloaded function
+ -- @f@ by applying it to the supplied dictionary @d@.
+ --
+ -- 'withDict' can only be used if the type class has a single method with no
+ -- superclasses.
+ --
+ -- @since 0.9.0
+ withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r
+
+{- Note [withDict has an ambiguous type]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The type of `withDict` is ambiguous. Consider
+ foo :: forall cls meth. WithDict cls meth
+ => forall rr (r::rr). meth -> (cls => r) -> r
+ foo m k = withDict m k
+
+If we instantiate `withDict` with fresh unification variables, including cls0 for cls,
+there is nothing that forces the `cls` Wanted from the call to `k` to unify with the
+`cls0` Given from the call to `withDict`. You have to give it a class argument:
+
+ foo m k = withDict @cls m k
+
+That's fine. But it means we need -XAllowAmbiguousTypes for the withDict definition,
+at least with deep subsumption.
+-}
diff --git a/GHC/Prim.hs b/GHC/Prim.hs
deleted file mode 100644
--- a/GHC/Prim.hs
+++ /dev/null
@@ -1,6619 +0,0 @@
-{-
-This is a generated file (generated by genprimopcode).
-It is not code to actually be used. Its only purpose is to be
-consumed by haddock.
--}
-
------------------------------------------------------------------------------
--- |
--- Module : GHC.Prim
---
--- Maintainer : ghc-devs@haskell.org
--- Stability : internal
--- Portability : non-portable (GHC extensions)
---
--- GHC's primitive types and operations.
--- Use GHC.Exts from the base package instead of importing this
--- module directly.
---
------------------------------------------------------------------------------
-{-# LANGUAGE Unsafe #-}
-{-# LANGUAGE MagicHash #-}
-{-# 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
-
-
-
diff --git a/GHC/Prim/Exception.hs b/GHC/Prim/Exception.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Prim/Exception.hs
@@ -0,0 +1,43 @@
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+-- | Primitive exceptions.
+--
+-- Users should not import this module. It is GHC internal only.
+module GHC.Prim.Exception
+ ( raiseOverflow
+ , raiseUnderflow
+ , raiseDivZero
+ )
+where
+
+import GHC.Prim
+
+-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base
+import GHC.Types ()
+
+default () -- Double and Integer aren't available yet
+
+-- Note [Arithmetic exceptions]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- ghc-prim provides several functions to raise arithmetic exceptions
+-- (raiseDivZero, raiseUnderflow, raiseOverflow) that are wired-in the RTS.
+-- These exceptions are meant to be used by the package implementing arbitrary
+-- precision numbers (Natural,Integer). It can't depend on `base` package to
+-- raise exceptions in a normal way because it would create a dependency
+-- cycle (base <-> bignum package). See #14664
+--
+-- See also: Note [Wired-in exceptions are not CAFfy] in GHC.Core.Make.
+
+-- | Raise 'GHC.Exception.Type.overflowException'
+raiseOverflow :: a
+raiseOverflow = raiseOverflow# (# #)
+
+-- | Raise 'GHC.Exception.Type.underflowException'
+raiseUnderflow :: a
+raiseUnderflow = raiseUnderflow# (# #)
+
+-- | Raise 'GHC.Exception.Type.divZeroException'
+raiseDivZero :: a
+raiseDivZero = raiseDivZero# (# #)
diff --git a/GHC/Prim/Ext.hs b/GHC/Prim/Ext.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Prim/Ext.hs
@@ -0,0 +1,249 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE GHCForeignImportPrim #-}
+{-# LANGUAGE UnliftedFFITypes #-}
+
+{-# OPTIONS_GHC -Wno-orphans -Wno-inline-rule-shadowing #-}
+
+-- We need platform defines (tests for mingw32 below).
+#include "ghcplatform.h"
+#include "MachDeps.h"
+
+-- See note [When do out-of-line primops go in primops.txt.pp]. More primops
+-- there are eligible according to the description below, but cannot yet be moved
+-- here because of superficial restrictions to `foreign import prim`. Hopefully
+-- that is fixed soon.
+
+-- | Extra C-- routines exposed from the RTS
+--
+-- Users should not import this module. It is GHC internal only. Use
+-- "GHC.Conc" instead.
+--
+-- Actual primops are emitted by the compiler itself. They are special bits of
+-- code with backend support. The foreign functions in this module aren't actual
+-- primops because the compiler doesn't care about them at all: they just are
+-- extra foreign C-- calls libraries can make into the RTS.
+--
+-- Note that 'GHC.Prim' has the same haddock section names as this module, but
+-- with descriptions. Consult that module's documentation for what each section means.
+-- are described over there.
+module GHC.Prim.Ext
+ (
+ -- * Misc
+ getThreadAllocationCounter#
+ -- * Delay\/wait operations
+#if defined(mingw32_HOST_OS)
+ , asyncRead#
+ , asyncWrite#
+ , asyncDoProc#
+#endif
+ ) where
+
+import GHC.Prim
+
+-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base
+import GHC.Types ()
+
+default () -- Double and Integer aren't available yet
+
+------------------------------------------------------------------------
+-- Delay/wait operations
+------------------------------------------------------------------------
+
+#if defined(mingw32_HOST_OS)
+
+-- | Asynchronously read bytes from specified file descriptor.
+foreign import prim "stg_asyncReadzh" asyncRead#
+ :: Int#
+ -> Int#
+ -> Int#
+ -> Addr#
+ -> State# RealWorld
+ -> (# State# RealWorld, Int#, Int# #)
+
+-- | Asynchronously write bytes from specified file descriptor.
+foreign import prim "stg_asyncWritezh" asyncWrite#
+ :: Int#
+ -> Int#
+ -> Int#
+ -> Addr#
+ -> State# RealWorld
+ -> (# State# RealWorld, Int#, Int# #)
+
+-- | Asynchronously perform procedure (first arg), passing it 2nd arg.
+foreign import prim "stg_asyncDoProczh" asyncDoProc#
+ :: Addr#
+ -> Addr#
+ -> State# RealWorld
+ -> (# State# RealWorld, Int#, Int# #)
+
+#endif
+
+------------------------------------------------------------------------
+-- Misc
+------------------------------------------------------------------------
+
+-- | Retrieves the allocation counter for the current thread.
+foreign import prim "stg_getThreadAllocationCounterzh" getThreadAllocationCounter#
+ :: State# RealWorld
+ -> (# State# RealWorld, Int64# #)
+
+------------------------------------------------------------------------
+-- Rules for primops that don't need to be built-in
+------------------------------------------------------------------------
+
+-- All these rules are used to remove useless casts:
+--
+-- 1. passing through a type with at least the same bit size:
+-- e.g. Int8# -> Int# -> Int8#
+-- ==> id
+--
+-- 2. passing through a (un)signed type of the same bit size:
+-- e.g. Word# -> Int# -> Word#
+-- ==> id
+--
+-- 3. one of the previous cases with signedness change:
+-- e.g. Int8# -> Int# -> Word# -> Word8#
+-- ==> Int8# -> Word8#
+--
+
+
+-- case 1:
+-- ~~~~~~~
+
+{-# RULES
+
+"Int8# -> Int# -> Int8#"
+ forall x . intToInt8# (int8ToInt# x) = x
+
+"Int16# -> Int# -> Int16#"
+ forall x . intToInt16# (int16ToInt# x) = x
+
+"Int32# -> Int# -> Int32#"
+ forall x . intToInt32# (int32ToInt# x) = x
+
+
+"Word8# -> Word# -> Word8#"
+ forall x . wordToWord8# (word8ToWord# x) = x
+
+"Word16# -> Word# -> Word16#"
+ forall x . wordToWord16# (word16ToWord# x) = x
+
+"Word32# -> Word# -> Word32#"
+ forall x . wordToWord32# (word32ToWord# x) = x
+
+
+"Int# -> Int64# -> Int#"
+ forall x . int64ToInt# (intToInt64# x) = x
+
+"Word# -> Word64# -> Word#"
+ forall x . word64ToWord# (wordToWord64# x) = x
+
+#-}
+
+#if WORD_SIZE_IN_BITS == 64
+{-# RULES
+
+"Int64# -> Int# -> Int64#"
+ forall x . intToInt64# (int64ToInt# x) = x
+
+"Word64# -> Word# -> Word64#"
+ forall x . wordToWord64# (word64ToWord# x) = x
+
+#-}
+#endif
+
+
+-- case 2:
+-- ~~~~~~~
+
+{-# RULES
+
+"Word# -> Int# -> Word#"
+ forall x . int2Word# (word2Int# x) = x
+
+"Int# -> Word# -> Int#"
+ forall x . word2Int# (int2Word# x) = x
+
+"Int8# -> Word8# -> Int8#"
+ forall x . word8ToInt8# (int8ToWord8# x) = x
+
+"Word8# -> Int8# -> Word8#"
+ forall x . int8ToWord8# (word8ToInt8# x) = x
+
+"Int16# -> Word16# -> Int16#"
+ forall x . word16ToInt16# (int16ToWord16# x) = x
+
+"Word16# -> Int16# -> Word16#"
+ forall x . int16ToWord16# (word16ToInt16# x) = x
+
+"Int32# -> Word32# -> Int32#"
+ forall x . word32ToInt32# (int32ToWord32# x) = x
+
+"Word32# -> Int32# -> Word32#"
+ forall x . int32ToWord32# (word32ToInt32# x) = x
+
+"Int64# -> Word64# -> Int64#"
+ forall x . word64ToInt64# (int64ToWord64# x) = x
+
+"Word64# -> Int64# -> Word64#"
+ forall x . int64ToWord64# (word64ToInt64# x) = x
+
+#-}
+
+-- case 3:
+-- ~~~~~~~
+
+{-# RULES
+
+"Int8# -> Int# -> Word# -> Word8#"
+ forall x . wordToWord8# (int2Word# (int8ToInt# x)) = int8ToWord8# x
+
+"Int16# -> Int# -> Word# -> Word16#"
+ forall x . wordToWord16# (int2Word# (int16ToInt# x)) = int16ToWord16# x
+
+"Int32# -> Int# -> Word# -> Word32#"
+ forall x . wordToWord32# (int2Word# (int32ToInt# x)) = int32ToWord32# x
+
+"Word8# -> Word# -> Int# -> Int8#"
+ forall x . intToInt8# (word2Int# (word8ToWord# x)) = word8ToInt8# x
+
+"Word16# -> Word# -> Int# -> Int16#"
+ forall x . intToInt16# (word2Int# (word16ToWord# x)) = word16ToInt16# x
+
+"Word32# -> Word# -> Int# -> Int32#"
+ forall x . intToInt32# (word2Int# (word32ToWord# x)) = word32ToInt32# x
+
+"Word# -> Word64# -> Int64# -> Int#"
+ forall x. int64ToInt# (word64ToInt64# (wordToWord64# x)) = word2Int# x
+
+"Int# -> Int64# -> Word64# -> Word#"
+ forall x. word64ToWord# (int64ToWord64# (intToInt64# x)) = int2Word# x
+
+#-}
+
+#if WORD_SIZE_IN_BITS == 64
+{-# RULES
+"Int64# -> Int# -> Word# -> Word64#"
+ forall x . wordToWord64# (int2Word# (int64ToInt# x)) = int64ToWord64# x
+
+"Word64# -> Word# -> Int# -> Int64#"
+ forall x . intToInt64# (word2Int# (word64ToWord# x)) = word64ToInt64# x
+#-}
+#endif
+
+
+-- Push downcast into bitwise operations
+{-# RULES
+"word64ToWord#/and64#"
+ forall x y . word64ToWord# (and64# x y) = and# (word64ToWord# x) (word64ToWord# y)
+
+"word64ToWord#/or64#"
+ forall x y . word64ToWord# (or64# x y) = or# (word64ToWord# x) (word64ToWord# y)
+
+"word64ToWord#/xor64#"
+ forall x y . word64ToWord# (xor64# x y) = xor# (word64ToWord# x) (word64ToWord# y)
+
+#-}
diff --git a/GHC/Prim/Panic.hs b/GHC/Prim/Panic.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Prim/Panic.hs
@@ -0,0 +1,119 @@
+{-# LANGUAGE GHCForeignImportPrim #-}
+{-# LANGUAGE UnliftedFFITypes #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE EmptyCase #-}
+{-# LANGUAGE RankNTypes, KindSignatures #-}
+
+-- | Primitive panics.
+--
+-- Users should not import this module. It is GHC internal only.
+module GHC.Prim.Panic
+ ( absentSumFieldError
+ , panicError
+ , absentError, absentConstraintError
+ )
+where
+
+import GHC.Prim
+import GHC.Magic
+import GHC.Types( Type )
+
+default () -- Double and Integer aren't available yet
+
+{-
+Note [Compiler error functions]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Most error functions (such as pattern match failure) are defined
+in base:Control.Exception.Base. But absentError# and absentSumFieldError#
+are defined here in the ghc-prim package for two reasons:
+
+* GHC itself generates calls to these functions as a result of
+ strictness analysis, over which the programmer has no control. So
+ it is hard to ensure that no such calls exist in the modules
+ compiled "before" Control.Base.Exception. (E.g. when compiling
+ with -fdicts-strict.)
+
+* A consequence of defining them in ghc-prim is that the libraries
+ defining exceptions have not yet been built, so we can't make them
+ into proper Haskell exceptions.
+
+ However, if these functions are ever called, it's a /compiler/ error,
+ not a user error, so it seems acceptable that they cannot be caught.
+
+One might wonder why absentError doesn't just call panic#.
+For absent error we want to combine two parts, one static, one call site
+dependent into one error message. While for absentSumFieldError it's a
+static string.
+
+The easiest way to combine the two parts for absentError is to use a
+format string with `barf` in the RTS passing the *dynamic* part of the
+error as argument. There is no need to do any of this for
+absentSumFieldError as it's a static string there.
+
+The alternatives would be to:
+* Drop the call site specific information from absentError.
+ The call site specific information is at times very helpful for debugging
+ so I don't consider this an option.
+* Remove the common prefix. We would then need to include the prefix
+ in the call site specific string we pass to absentError. Increasing
+ code size for no good reason.
+
+Both of which seem worse than having an stg_absentError function specific to
+absentError to me.
+-}
+
+-- `stg_panic#` never returns but it can't just return `State# RealWorld` so we
+-- indicate that it returns `(# #)` too to make the compiler happy.
+-- See Note [Compiler error functions]
+foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, (# #) #)
+
+-- See Note [Compiler error functions]
+foreign import prim "stg_absentErrorzh" stg_absentError# :: Addr# -> State# RealWorld -> (# State# RealWorld, (# #) #)
+
+-- | Display the CString whose address is given as an argument and exit.
+panicError :: Addr# -> a
+panicError errmsg =
+ runRW# (\s ->
+ case panic# errmsg s of
+ (# _, _ #) -> -- This bottom is unreachable but we can't
+ -- use an empty case lest the pattern match
+ -- checker squawks.
+ let x = x in x)
+
+-- | Closure introduced by GHC.Stg.Unarise for unused unboxed sum fields.
+--
+-- See Note [aBSENT_SUM_FIELD_ERROR_ID] in GHC.Core.Make
+absentSumFieldError :: a
+absentSumFieldError = panicError "entered absent sum field!"#
+
+-- GHC.Core.Make.aBSENT_SUM_FIELD_ERROR_ID gives absentSumFieldError a bottoming
+-- demand signature. But if we ever inlined it (to a call to panicError) we'd
+-- lose that information. Should not happen because absentSumFieldError is only
+-- introduced in Stg.Unarise, long after inlining has stopped, but it seems
+-- more direct simply to give it a NOINLINE pragma
+{-# NOINLINE absentSumFieldError #-}
+
+-- | Displays "Oops! Entered absent arg" ++ errormsg and exits the program.
+{-# NOINLINE absentError #-}
+absentError :: forall (a :: Type). Addr# -> a
+absentError errmsg =
+ runRW# (\s ->
+ case stg_absentError# errmsg s of
+ (# _, _ #) -> -- This bottom is unreachable but we can't
+ -- use an empty case lest the pattern match
+ -- checker squawks.
+ let x = x in x)
+
+{-# NOINLINE absentConstraintError #-}
+absentConstraintError :: forall (a :: Type). Addr# -> a
+-- We want to give this the type
+-- forall (a :: Constraint). Addr# -> a
+-- but Haskell source code doesn't allow functions that return Constraint
+-- So in this module we lie about the type. This is fine because
+-- absentConstraintError is a wired-in Id with the desired Constraint-kinded
+-- type; the type in the interface file is never looked at.
+-- The only purpose of this definition is to give a function to call,
+-- and for that purpose, delegating to absentError is fine.
+absentConstraintError errmsg = absentError errmsg
diff --git a/GHC/Prim/PtrEq.hs b/GHC/Prim/PtrEq.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Prim/PtrEq.hs
@@ -0,0 +1,153 @@
+{-# LANGUAGE Unsafe #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE PolyKinds #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Prim.PtrEq
+-- License : see libraries/ghc-prim/LICENSE
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Stability : internal
+-- Portability : non-portable (GHC Extensions)
+--
+-- Comparing underlying pointers for equality.
+--
+-- Use GHC.Exts from the base package instead of importing this
+-- module directly.
+--
+-----------------------------------------------------------------------------
+
+module GHC.Prim.PtrEq
+ ( reallyUnsafePtrEquality,
+ unsafePtrEquality#,
+ sameArray#,
+ sameMutableArray#,
+ sameSmallArray#,
+ sameSmallMutableArray#,
+ sameByteArray#,
+ sameMutableByteArray#,
+ sameMutVar#,
+ sameTVar#,
+ sameMVar#,
+ sameIOPort#,
+ samePromptTag#,
+ eqStableName#
+ ) where
+
+import GHC.Prim
+import GHC.Types -- Also make implicit dependency known to build system
+ ( RuntimeRep(BoxedRep), UnliftedType )
+default () -- Double and Integer aren't available yet
+
+{- **********************************************************************
+* *
+* Pointer equality *
+* *
+********************************************************************** -}
+
+{- Note [Pointer equality operations]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Many primitive types - such as Array#, ByteArray#, MVar#, ... - are boxed:
+they are represented by pointers to the underlying data. It is thus possible
+to directly compare these pointers for equality, as opposed to comparing
+the underlying data that the pointers refer to (for instance, comparing
+two arrays element-wise).
+
+To do this, GHC provides the primop reallyUnsafePtrEquality#, which is
+both levity-polymorphic and heterogeneous. As its name indicates, it is an
+unsafe operation which can yield unpredictable results, as explained in
+Note [Pointer comparison operations] in primops.txt.pp
+
+For a more user-friendly interface, this module defines specialisations of
+the reallyUnsafePtrEquality# primop at various primitive types, such as
+Array#, ByteArray#, MVar#, ...
+-}
+
+-- | Compare the underlying pointers of two values for equality.
+--
+-- Returns @1@ if the pointers are equal and @0@ otherwise.
+--
+-- The two values must be of the same type, of kind 'Type'.
+-- See also 'GHC.Exts.reallyUnsafePtrEquality#', which doesn't have
+-- such restrictions.
+reallyUnsafePtrEquality :: a -> a -> Int#
+reallyUnsafePtrEquality = reallyUnsafePtrEquality#
+-- See Note [Pointer comparison operations]
+-- in primops.txt.pp
+
+-- | Compare the underlying pointers of two unlifted values for equality.
+--
+-- This is less dangerous than 'reallyUnsafePtrEquality',
+-- since the arguments are guaranteed to be evaluated.
+-- This means there is no risk of accidentally comparing
+-- a thunk.
+-- It's however still more dangerous than e.g. 'sameArray#'.
+--
+unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#
+unsafePtrEquality# = reallyUnsafePtrEquality#
+-- See Note [Pointer comparison operations]
+-- in primops.txt.pp
+
+-- | Compare the underlying pointers of two arrays.
+sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
+sameArray# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two mutable arrays.
+sameMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
+sameMutableArray# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two small arrays.
+sameSmallArray# :: forall {l} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
+sameSmallArray# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two small mutable arrays.
+sameSmallMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+sameSmallMutableArray# = unsafePtrEquality#
+
+-- | Compare the pointers of two byte arrays.
+sameByteArray# :: ByteArray# -> ByteArray# -> Int#
+sameByteArray# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two mutable byte arrays.
+sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
+sameMutableByteArray# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two 'MutVar#'s.
+sameMutVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
+sameMutVar# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two 'TVar#'s.
+sameTVar# :: forall {l} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int#
+sameTVar# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two 'MVar#'s.
+sameMVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int#
+sameMVar# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two 'IOPort#'s.
+sameIOPort# :: forall {l} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
+sameIOPort# = unsafePtrEquality#
+
+-- | Compare the underlying pointers of two 'PromptTag#'s.
+samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int#
+samePromptTag# = unsafePtrEquality#
+
+-- Note [Comparing stable names]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- A StableName# is actually a pointer to a stable name object (SNO)
+-- containing an index into the stable name table (SNT). We
+-- used to compare StableName#s by following the pointers to the
+-- SNOs and checking whether they held the same SNT indices. However,
+-- this is not necessary: there is a one-to-one correspondence
+-- between SNOs and entries in the SNT, so simple pointer equality
+-- does the trick.
+
+-- | Compare two stable names for equality.
+eqStableName# :: forall {k} {l} (a :: TYPE (BoxedRep k)) (b :: TYPE (BoxedRep l))
+ . StableName# a -> StableName# b -> Int#
+eqStableName# = unsafePtrEquality#
diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs
--- a/GHC/PrimopWrappers.hs
+++ b/GHC/PrimopWrappers.hs
@@ -1,1220 +1,2213 @@
-{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-}
-module GHC.PrimopWrappers where
-import qualified GHC.Prim
-import GHC.Tuple ()
-import GHC.Prim (Char#, Int#, Word#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, BCO#)
-{-# NOINLINE gtChar# #-}
-gtChar# :: Char# -> Char# -> Int#
-gtChar# a1 a2 = (GHC.Prim.gtChar#) a1 a2
-{-# NOINLINE geChar# #-}
-geChar# :: Char# -> Char# -> Int#
-geChar# a1 a2 = (GHC.Prim.geChar#) a1 a2
-{-# NOINLINE eqChar# #-}
-eqChar# :: Char# -> Char# -> Int#
-eqChar# a1 a2 = (GHC.Prim.eqChar#) a1 a2
-{-# NOINLINE neChar# #-}
-neChar# :: Char# -> Char# -> Int#
-neChar# a1 a2 = (GHC.Prim.neChar#) a1 a2
-{-# NOINLINE ltChar# #-}
-ltChar# :: Char# -> Char# -> Int#
-ltChar# a1 a2 = (GHC.Prim.ltChar#) a1 a2
-{-# NOINLINE leChar# #-}
-leChar# :: Char# -> Char# -> Int#
-leChar# a1 a2 = (GHC.Prim.leChar#) a1 a2
-{-# NOINLINE ord# #-}
-ord# :: Char# -> Int#
-ord# a1 = (GHC.Prim.ord#) a1
-{-# NOINLINE (+#) #-}
-(+#) :: Int# -> Int# -> Int#
-(+#) a1 a2 = (GHC.Prim.+#) a1 a2
-{-# NOINLINE (-#) #-}
-(-#) :: Int# -> Int# -> Int#
-(-#) a1 a2 = (GHC.Prim.-#) a1 a2
-{-# NOINLINE (*#) #-}
-(*#) :: Int# -> Int# -> Int#
-(*#) a1 a2 = (GHC.Prim.*#) a1 a2
-{-# NOINLINE mulIntMayOflo# #-}
-mulIntMayOflo# :: Int# -> Int# -> Int#
-mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2
-{-# NOINLINE quotInt# #-}
-quotInt# :: Int# -> Int# -> Int#
-quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2
-{-# NOINLINE remInt# #-}
-remInt# :: Int# -> Int# -> Int#
-remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2
-{-# NOINLINE quotRemInt# #-}
-quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)
-quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2
-{-# NOINLINE andI# #-}
-andI# :: Int# -> Int# -> Int#
-andI# a1 a2 = (GHC.Prim.andI#) a1 a2
-{-# NOINLINE orI# #-}
-orI# :: Int# -> Int# -> Int#
-orI# a1 a2 = (GHC.Prim.orI#) a1 a2
-{-# NOINLINE xorI# #-}
-xorI# :: Int# -> Int# -> Int#
-xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2
-{-# NOINLINE notI# #-}
-notI# :: Int# -> Int#
-notI# a1 = (GHC.Prim.notI#) a1
-{-# NOINLINE negateInt# #-}
-negateInt# :: Int# -> Int#
-negateInt# a1 = (GHC.Prim.negateInt#) a1
-{-# NOINLINE addIntC# #-}
-addIntC# :: Int# -> Int# -> (# Int#,Int# #)
-addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2
-{-# NOINLINE subIntC# #-}
-subIntC# :: Int# -> Int# -> (# Int#,Int# #)
-subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2
-{-# NOINLINE (>#) #-}
-(>#) :: Int# -> Int# -> Int#
-(>#) a1 a2 = (GHC.Prim.>#) a1 a2
-{-# NOINLINE (>=#) #-}
-(>=#) :: Int# -> Int# -> Int#
-(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2
-{-# NOINLINE (==#) #-}
-(==#) :: Int# -> Int# -> Int#
-(==#) a1 a2 = (GHC.Prim.==#) a1 a2
-{-# NOINLINE (/=#) #-}
-(/=#) :: Int# -> Int# -> Int#
-(/=#) a1 a2 = (GHC.Prim./=#) a1 a2
-{-# NOINLINE (<#) #-}
-(<#) :: Int# -> Int# -> Int#
-(<#) a1 a2 = (GHC.Prim.<#) a1 a2
-{-# NOINLINE (<=#) #-}
-(<=#) :: Int# -> Int# -> Int#
-(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2
-{-# NOINLINE chr# #-}
-chr# :: Int# -> Char#
-chr# a1 = (GHC.Prim.chr#) a1
-{-# NOINLINE int2Word# #-}
-int2Word# :: Int# -> Word#
-int2Word# a1 = (GHC.Prim.int2Word#) a1
-{-# NOINLINE int2Float# #-}
-int2Float# :: Int# -> Float#
-int2Float# a1 = (GHC.Prim.int2Float#) a1
-{-# NOINLINE int2Double# #-}
-int2Double# :: Int# -> Double#
-int2Double# a1 = (GHC.Prim.int2Double#) a1
-{-# NOINLINE word2Float# #-}
-word2Float# :: Word# -> Float#
-word2Float# a1 = (GHC.Prim.word2Float#) a1
-{-# NOINLINE word2Double# #-}
-word2Double# :: Word# -> Double#
-word2Double# a1 = (GHC.Prim.word2Double#) a1
-{-# NOINLINE uncheckedIShiftL# #-}
-uncheckedIShiftL# :: Int# -> Int# -> Int#
-uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2
-{-# NOINLINE uncheckedIShiftRA# #-}
-uncheckedIShiftRA# :: Int# -> Int# -> Int#
-uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2
-{-# NOINLINE uncheckedIShiftRL# #-}
-uncheckedIShiftRL# :: Int# -> Int# -> Int#
-uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2
-{-# NOINLINE plusWord# #-}
-plusWord# :: Word# -> Word# -> Word#
-plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2
-{-# NOINLINE plusWord2# #-}
-plusWord2# :: Word# -> Word# -> (# Word#,Word# #)
-plusWord2# a1 a2 = (GHC.Prim.plusWord2#) a1 a2
-{-# NOINLINE minusWord# #-}
-minusWord# :: Word# -> Word# -> Word#
-minusWord# a1 a2 = (GHC.Prim.minusWord#) a1 a2
-{-# NOINLINE timesWord# #-}
-timesWord# :: Word# -> Word# -> Word#
-timesWord# a1 a2 = (GHC.Prim.timesWord#) a1 a2
-{-# NOINLINE timesWord2# #-}
-timesWord2# :: Word# -> Word# -> (# Word#,Word# #)
-timesWord2# a1 a2 = (GHC.Prim.timesWord2#) a1 a2
-{-# NOINLINE quotWord# #-}
-quotWord# :: Word# -> Word# -> Word#
-quotWord# a1 a2 = (GHC.Prim.quotWord#) a1 a2
-{-# NOINLINE remWord# #-}
-remWord# :: Word# -> Word# -> Word#
-remWord# a1 a2 = (GHC.Prim.remWord#) a1 a2
-{-# NOINLINE quotRemWord# #-}
-quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)
-quotRemWord# a1 a2 = (GHC.Prim.quotRemWord#) a1 a2
-{-# NOINLINE quotRemWord2# #-}
-quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)
-quotRemWord2# a1 a2 a3 = (GHC.Prim.quotRemWord2#) a1 a2 a3
-{-# NOINLINE and# #-}
-and# :: Word# -> Word# -> Word#
-and# a1 a2 = (GHC.Prim.and#) a1 a2
-{-# NOINLINE or# #-}
-or# :: Word# -> Word# -> Word#
-or# a1 a2 = (GHC.Prim.or#) a1 a2
-{-# NOINLINE xor# #-}
-xor# :: Word# -> Word# -> Word#
-xor# a1 a2 = (GHC.Prim.xor#) a1 a2
-{-# NOINLINE not# #-}
-not# :: Word# -> Word#
-not# a1 = (GHC.Prim.not#) a1
-{-# NOINLINE uncheckedShiftL# #-}
-uncheckedShiftL# :: Word# -> Int# -> Word#
-uncheckedShiftL# a1 a2 = (GHC.Prim.uncheckedShiftL#) a1 a2
-{-# NOINLINE uncheckedShiftRL# #-}
-uncheckedShiftRL# :: Word# -> Int# -> Word#
-uncheckedShiftRL# a1 a2 = (GHC.Prim.uncheckedShiftRL#) a1 a2
-{-# NOINLINE word2Int# #-}
-word2Int# :: Word# -> Int#
-word2Int# a1 = (GHC.Prim.word2Int#) a1
-{-# NOINLINE gtWord# #-}
-gtWord# :: Word# -> Word# -> Int#
-gtWord# a1 a2 = (GHC.Prim.gtWord#) a1 a2
-{-# NOINLINE geWord# #-}
-geWord# :: Word# -> Word# -> Int#
-geWord# a1 a2 = (GHC.Prim.geWord#) a1 a2
-{-# NOINLINE eqWord# #-}
-eqWord# :: Word# -> Word# -> Int#
-eqWord# a1 a2 = (GHC.Prim.eqWord#) a1 a2
-{-# NOINLINE neWord# #-}
-neWord# :: Word# -> Word# -> Int#
-neWord# a1 a2 = (GHC.Prim.neWord#) a1 a2
-{-# NOINLINE ltWord# #-}
-ltWord# :: Word# -> Word# -> Int#
-ltWord# a1 a2 = (GHC.Prim.ltWord#) a1 a2
-{-# NOINLINE leWord# #-}
-leWord# :: Word# -> Word# -> Int#
-leWord# a1 a2 = (GHC.Prim.leWord#) a1 a2
-{-# NOINLINE popCnt8# #-}
-popCnt8# :: Word# -> Word#
-popCnt8# a1 = (GHC.Prim.popCnt8#) a1
-{-# NOINLINE popCnt16# #-}
-popCnt16# :: Word# -> Word#
-popCnt16# a1 = (GHC.Prim.popCnt16#) a1
-{-# NOINLINE popCnt32# #-}
-popCnt32# :: Word# -> Word#
-popCnt32# a1 = (GHC.Prim.popCnt32#) a1
-{-# NOINLINE popCnt64# #-}
-popCnt64# :: Word# -> Word#
-popCnt64# a1 = (GHC.Prim.popCnt64#) a1
-{-# NOINLINE popCnt# #-}
-popCnt# :: Word# -> Word#
-popCnt# a1 = (GHC.Prim.popCnt#) a1
-{-# NOINLINE clz8# #-}
-clz8# :: Word# -> Word#
-clz8# a1 = (GHC.Prim.clz8#) a1
-{-# NOINLINE clz16# #-}
-clz16# :: Word# -> Word#
-clz16# a1 = (GHC.Prim.clz16#) a1
-{-# NOINLINE clz32# #-}
-clz32# :: Word# -> Word#
-clz32# a1 = (GHC.Prim.clz32#) a1
-{-# NOINLINE clz64# #-}
-clz64# :: Word# -> Word#
-clz64# a1 = (GHC.Prim.clz64#) a1
-{-# NOINLINE clz# #-}
-clz# :: Word# -> Word#
-clz# a1 = (GHC.Prim.clz#) a1
-{-# NOINLINE ctz8# #-}
-ctz8# :: Word# -> Word#
-ctz8# a1 = (GHC.Prim.ctz8#) a1
-{-# NOINLINE ctz16# #-}
-ctz16# :: Word# -> Word#
-ctz16# a1 = (GHC.Prim.ctz16#) a1
-{-# NOINLINE ctz32# #-}
-ctz32# :: Word# -> Word#
-ctz32# a1 = (GHC.Prim.ctz32#) a1
-{-# NOINLINE ctz64# #-}
-ctz64# :: Word# -> Word#
-ctz64# a1 = (GHC.Prim.ctz64#) a1
-{-# NOINLINE ctz# #-}
-ctz# :: Word# -> Word#
-ctz# a1 = (GHC.Prim.ctz#) a1
-{-# NOINLINE byteSwap16# #-}
-byteSwap16# :: Word# -> Word#
-byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1
-{-# NOINLINE byteSwap32# #-}
-byteSwap32# :: Word# -> Word#
-byteSwap32# a1 = (GHC.Prim.byteSwap32#) a1
-{-# NOINLINE byteSwap64# #-}
-byteSwap64# :: Word# -> Word#
-byteSwap64# a1 = (GHC.Prim.byteSwap64#) a1
-{-# NOINLINE byteSwap# #-}
-byteSwap# :: Word# -> Word#
-byteSwap# a1 = (GHC.Prim.byteSwap#) a1
-{-# NOINLINE narrow8Int# #-}
-narrow8Int# :: Int# -> Int#
-narrow8Int# a1 = (GHC.Prim.narrow8Int#) a1
-{-# NOINLINE narrow16Int# #-}
-narrow16Int# :: Int# -> Int#
-narrow16Int# a1 = (GHC.Prim.narrow16Int#) a1
-{-# NOINLINE narrow32Int# #-}
-narrow32Int# :: Int# -> Int#
-narrow32Int# a1 = (GHC.Prim.narrow32Int#) a1
-{-# NOINLINE narrow8Word# #-}
-narrow8Word# :: Word# -> Word#
-narrow8Word# a1 = (GHC.Prim.narrow8Word#) a1
-{-# NOINLINE narrow16Word# #-}
-narrow16Word# :: Word# -> Word#
-narrow16Word# a1 = (GHC.Prim.narrow16Word#) a1
-{-# NOINLINE narrow32Word# #-}
-narrow32Word# :: Word# -> Word#
-narrow32Word# a1 = (GHC.Prim.narrow32Word#) a1
-{-# NOINLINE (>##) #-}
-(>##) :: Double# -> Double# -> Int#
-(>##) a1 a2 = (GHC.Prim.>##) a1 a2
-{-# NOINLINE (>=##) #-}
-(>=##) :: Double# -> Double# -> Int#
-(>=##) a1 a2 = (GHC.Prim.>=##) a1 a2
-{-# NOINLINE (==##) #-}
-(==##) :: Double# -> Double# -> Int#
-(==##) a1 a2 = (GHC.Prim.==##) a1 a2
-{-# NOINLINE (/=##) #-}
-(/=##) :: Double# -> Double# -> Int#
-(/=##) a1 a2 = (GHC.Prim./=##) a1 a2
-{-# NOINLINE (<##) #-}
-(<##) :: Double# -> Double# -> Int#
-(<##) a1 a2 = (GHC.Prim.<##) a1 a2
-{-# NOINLINE (<=##) #-}
-(<=##) :: Double# -> Double# -> Int#
-(<=##) a1 a2 = (GHC.Prim.<=##) a1 a2
-{-# NOINLINE (+##) #-}
-(+##) :: Double# -> Double# -> Double#
-(+##) a1 a2 = (GHC.Prim.+##) a1 a2
-{-# NOINLINE (-##) #-}
-(-##) :: Double# -> Double# -> Double#
-(-##) a1 a2 = (GHC.Prim.-##) a1 a2
-{-# NOINLINE (*##) #-}
-(*##) :: Double# -> Double# -> Double#
-(*##) a1 a2 = (GHC.Prim.*##) a1 a2
-{-# NOINLINE (/##) #-}
-(/##) :: Double# -> Double# -> Double#
-(/##) a1 a2 = (GHC.Prim./##) a1 a2
-{-# NOINLINE negateDouble# #-}
-negateDouble# :: Double# -> Double#
-negateDouble# a1 = (GHC.Prim.negateDouble#) a1
-{-# NOINLINE double2Int# #-}
-double2Int# :: Double# -> Int#
-double2Int# a1 = (GHC.Prim.double2Int#) a1
-{-# NOINLINE double2Float# #-}
-double2Float# :: Double# -> Float#
-double2Float# a1 = (GHC.Prim.double2Float#) a1
-{-# NOINLINE expDouble# #-}
-expDouble# :: Double# -> Double#
-expDouble# a1 = (GHC.Prim.expDouble#) a1
-{-# NOINLINE logDouble# #-}
-logDouble# :: Double# -> Double#
-logDouble# a1 = (GHC.Prim.logDouble#) a1
-{-# NOINLINE sqrtDouble# #-}
-sqrtDouble# :: Double# -> Double#
-sqrtDouble# a1 = (GHC.Prim.sqrtDouble#) a1
-{-# NOINLINE sinDouble# #-}
-sinDouble# :: Double# -> Double#
-sinDouble# a1 = (GHC.Prim.sinDouble#) a1
-{-# NOINLINE cosDouble# #-}
-cosDouble# :: Double# -> Double#
-cosDouble# a1 = (GHC.Prim.cosDouble#) a1
-{-# NOINLINE tanDouble# #-}
-tanDouble# :: Double# -> Double#
-tanDouble# a1 = (GHC.Prim.tanDouble#) a1
-{-# NOINLINE asinDouble# #-}
-asinDouble# :: Double# -> Double#
-asinDouble# a1 = (GHC.Prim.asinDouble#) a1
-{-# NOINLINE acosDouble# #-}
-acosDouble# :: Double# -> Double#
-acosDouble# a1 = (GHC.Prim.acosDouble#) a1
-{-# NOINLINE atanDouble# #-}
-atanDouble# :: Double# -> Double#
-atanDouble# a1 = (GHC.Prim.atanDouble#) a1
-{-# NOINLINE sinhDouble# #-}
-sinhDouble# :: Double# -> Double#
-sinhDouble# a1 = (GHC.Prim.sinhDouble#) a1
-{-# NOINLINE coshDouble# #-}
-coshDouble# :: Double# -> Double#
-coshDouble# a1 = (GHC.Prim.coshDouble#) a1
-{-# NOINLINE tanhDouble# #-}
-tanhDouble# :: Double# -> Double#
-tanhDouble# a1 = (GHC.Prim.tanhDouble#) a1
-{-# NOINLINE (**##) #-}
-(**##) :: Double# -> Double# -> Double#
-(**##) a1 a2 = (GHC.Prim.**##) a1 a2
-{-# NOINLINE decodeDouble_2Int# #-}
-decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)
-decodeDouble_2Int# a1 = (GHC.Prim.decodeDouble_2Int#) a1
-{-# NOINLINE decodeDouble_Int64# #-}
-decodeDouble_Int64# :: Double# -> (# Int#,Int# #)
-decodeDouble_Int64# a1 = (GHC.Prim.decodeDouble_Int64#) a1
-{-# NOINLINE gtFloat# #-}
-gtFloat# :: Float# -> Float# -> Int#
-gtFloat# a1 a2 = (GHC.Prim.gtFloat#) a1 a2
-{-# NOINLINE geFloat# #-}
-geFloat# :: Float# -> Float# -> Int#
-geFloat# a1 a2 = (GHC.Prim.geFloat#) a1 a2
-{-# NOINLINE eqFloat# #-}
-eqFloat# :: Float# -> Float# -> Int#
-eqFloat# a1 a2 = (GHC.Prim.eqFloat#) a1 a2
-{-# NOINLINE neFloat# #-}
-neFloat# :: Float# -> Float# -> Int#
-neFloat# a1 a2 = (GHC.Prim.neFloat#) a1 a2
-{-# NOINLINE ltFloat# #-}
-ltFloat# :: Float# -> Float# -> Int#
-ltFloat# a1 a2 = (GHC.Prim.ltFloat#) a1 a2
-{-# NOINLINE leFloat# #-}
-leFloat# :: Float# -> Float# -> Int#
-leFloat# a1 a2 = (GHC.Prim.leFloat#) a1 a2
-{-# NOINLINE plusFloat# #-}
-plusFloat# :: Float# -> Float# -> Float#
-plusFloat# a1 a2 = (GHC.Prim.plusFloat#) a1 a2
-{-# NOINLINE minusFloat# #-}
-minusFloat# :: Float# -> Float# -> Float#
-minusFloat# a1 a2 = (GHC.Prim.minusFloat#) a1 a2
-{-# NOINLINE timesFloat# #-}
-timesFloat# :: Float# -> Float# -> Float#
-timesFloat# a1 a2 = (GHC.Prim.timesFloat#) a1 a2
-{-# NOINLINE divideFloat# #-}
-divideFloat# :: Float# -> Float# -> Float#
-divideFloat# a1 a2 = (GHC.Prim.divideFloat#) a1 a2
-{-# NOINLINE negateFloat# #-}
-negateFloat# :: Float# -> Float#
-negateFloat# a1 = (GHC.Prim.negateFloat#) a1
-{-# NOINLINE float2Int# #-}
-float2Int# :: Float# -> Int#
-float2Int# a1 = (GHC.Prim.float2Int#) a1
-{-# NOINLINE expFloat# #-}
-expFloat# :: Float# -> Float#
-expFloat# a1 = (GHC.Prim.expFloat#) a1
-{-# NOINLINE logFloat# #-}
-logFloat# :: Float# -> Float#
-logFloat# a1 = (GHC.Prim.logFloat#) a1
-{-# NOINLINE sqrtFloat# #-}
-sqrtFloat# :: Float# -> Float#
-sqrtFloat# a1 = (GHC.Prim.sqrtFloat#) a1
-{-# NOINLINE sinFloat# #-}
-sinFloat# :: Float# -> Float#
-sinFloat# a1 = (GHC.Prim.sinFloat#) a1
-{-# NOINLINE cosFloat# #-}
-cosFloat# :: Float# -> Float#
-cosFloat# a1 = (GHC.Prim.cosFloat#) a1
-{-# NOINLINE tanFloat# #-}
-tanFloat# :: Float# -> Float#
-tanFloat# a1 = (GHC.Prim.tanFloat#) a1
-{-# NOINLINE asinFloat# #-}
-asinFloat# :: Float# -> Float#
-asinFloat# a1 = (GHC.Prim.asinFloat#) a1
-{-# NOINLINE acosFloat# #-}
-acosFloat# :: Float# -> Float#
-acosFloat# a1 = (GHC.Prim.acosFloat#) a1
-{-# NOINLINE atanFloat# #-}
-atanFloat# :: Float# -> Float#
-atanFloat# a1 = (GHC.Prim.atanFloat#) a1
-{-# NOINLINE sinhFloat# #-}
-sinhFloat# :: Float# -> Float#
-sinhFloat# a1 = (GHC.Prim.sinhFloat#) a1
-{-# NOINLINE coshFloat# #-}
-coshFloat# :: Float# -> Float#
-coshFloat# a1 = (GHC.Prim.coshFloat#) a1
-{-# NOINLINE tanhFloat# #-}
-tanhFloat# :: Float# -> Float#
-tanhFloat# a1 = (GHC.Prim.tanhFloat#) a1
-{-# NOINLINE powerFloat# #-}
-powerFloat# :: Float# -> Float# -> Float#
-powerFloat# a1 a2 = (GHC.Prim.powerFloat#) a1 a2
-{-# NOINLINE float2Double# #-}
-float2Double# :: Float# -> Double#
-float2Double# a1 = (GHC.Prim.float2Double#) a1
-{-# NOINLINE decodeFloat_Int# #-}
-decodeFloat_Int# :: Float# -> (# Int#,Int# #)
-decodeFloat_Int# a1 = (GHC.Prim.decodeFloat_Int#) a1
-{-# NOINLINE newArray# #-}
-newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)
-newArray# a1 a2 a3 = (GHC.Prim.newArray#) a1 a2 a3
-{-# NOINLINE sameMutableArray# #-}
-sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#
-sameMutableArray# a1 a2 = (GHC.Prim.sameMutableArray#) a1 a2
-{-# NOINLINE readArray# #-}
-readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)
-readArray# a1 a2 a3 = (GHC.Prim.readArray#) a1 a2 a3
-{-# NOINLINE writeArray# #-}
-writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s
-writeArray# a1 a2 a3 a4 = (GHC.Prim.writeArray#) a1 a2 a3 a4
-{-# NOINLINE sizeofArray# #-}
-sizeofArray# :: Array# a -> Int#
-sizeofArray# a1 = (GHC.Prim.sizeofArray#) a1
-{-# NOINLINE sizeofMutableArray# #-}
-sizeofMutableArray# :: MutableArray# s a -> Int#
-sizeofMutableArray# a1 = (GHC.Prim.sizeofMutableArray#) a1
-{-# NOINLINE indexArray# #-}
-indexArray# :: Array# a -> Int# -> (# a #)
-indexArray# a1 a2 = (GHC.Prim.indexArray#) a1 a2
-{-# NOINLINE unsafeFreezeArray# #-}
-unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)
-unsafeFreezeArray# a1 a2 = (GHC.Prim.unsafeFreezeArray#) a1 a2
-{-# NOINLINE unsafeThawArray# #-}
-unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)
-unsafeThawArray# a1 a2 = (GHC.Prim.unsafeThawArray#) a1 a2
-{-# NOINLINE copyArray# #-}
-copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
-copyArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE copyMutableArray# #-}
-copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
-copyMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE cloneArray# #-}
-cloneArray# :: Array# a -> Int# -> Int# -> Array# a
-cloneArray# a1 a2 a3 = (GHC.Prim.cloneArray#) a1 a2 a3
-{-# NOINLINE cloneMutableArray# #-}
-cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
-cloneMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneMutableArray#) a1 a2 a3 a4
-{-# NOINLINE freezeArray# #-}
-freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)
-freezeArray# a1 a2 a3 a4 = (GHC.Prim.freezeArray#) a1 a2 a3 a4
-{-# NOINLINE thawArray# #-}
-thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
-thawArray# a1 a2 a3 a4 = (GHC.Prim.thawArray#) a1 a2 a3 a4
-{-# NOINLINE casArray# #-}
-casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)
-casArray# a1 a2 a3 a4 a5 = (GHC.Prim.casArray#) a1 a2 a3 a4 a5
-{-# NOINLINE newSmallArray# #-}
-newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #)
-newSmallArray# a1 a2 a3 = (GHC.Prim.newSmallArray#) a1 a2 a3
-{-# NOINLINE sameSmallMutableArray# #-}
-sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
-sameSmallMutableArray# a1 a2 = (GHC.Prim.sameSmallMutableArray#) a1 a2
-{-# NOINLINE readSmallArray# #-}
-readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #)
-readSmallArray# a1 a2 a3 = (GHC.Prim.readSmallArray#) a1 a2 a3
-{-# NOINLINE writeSmallArray# #-}
-writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
-writeSmallArray# a1 a2 a3 a4 = (GHC.Prim.writeSmallArray#) a1 a2 a3 a4
-{-# NOINLINE sizeofSmallArray# #-}
-sizeofSmallArray# :: SmallArray# a -> Int#
-sizeofSmallArray# a1 = (GHC.Prim.sizeofSmallArray#) a1
-{-# NOINLINE sizeofSmallMutableArray# #-}
-sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#
-sizeofSmallMutableArray# a1 = (GHC.Prim.sizeofSmallMutableArray#) a1
-{-# NOINLINE indexSmallArray# #-}
-indexSmallArray# :: SmallArray# a -> Int# -> (# a #)
-indexSmallArray# a1 a2 = (GHC.Prim.indexSmallArray#) a1 a2
-{-# NOINLINE unsafeFreezeSmallArray# #-}
-unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #)
-unsafeFreezeSmallArray# a1 a2 = (GHC.Prim.unsafeFreezeSmallArray#) a1 a2
-{-# NOINLINE unsafeThawSmallArray# #-}
-unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #)
-unsafeThawSmallArray# a1 a2 = (GHC.Prim.unsafeThawSmallArray#) a1 a2
-{-# NOINLINE copySmallArray# #-}
-copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
-copySmallArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE copySmallMutableArray# #-}
-copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
-copySmallMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallMutableArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE cloneSmallArray# #-}
-cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a
-cloneSmallArray# a1 a2 a3 = (GHC.Prim.cloneSmallArray#) a1 a2 a3
-{-# NOINLINE cloneSmallMutableArray# #-}
-cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)
-cloneSmallMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneSmallMutableArray#) a1 a2 a3 a4
-{-# NOINLINE freezeSmallArray# #-}
-freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #)
-freezeSmallArray# a1 a2 a3 a4 = (GHC.Prim.freezeSmallArray#) a1 a2 a3 a4
-{-# NOINLINE thawSmallArray# #-}
-thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)
-thawSmallArray# a1 a2 a3 a4 = (GHC.Prim.thawSmallArray#) a1 a2 a3 a4
-{-# NOINLINE casSmallArray# #-}
-casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)
-casSmallArray# a1 a2 a3 a4 a5 = (GHC.Prim.casSmallArray#) a1 a2 a3 a4 a5
-{-# NOINLINE newByteArray# #-}
-newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
-newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2
-{-# NOINLINE newPinnedByteArray# #-}
-newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
-newPinnedByteArray# a1 a2 = (GHC.Prim.newPinnedByteArray#) a1 a2
-{-# NOINLINE newAlignedPinnedByteArray# #-}
-newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
-newAlignedPinnedByteArray# a1 a2 a3 = (GHC.Prim.newAlignedPinnedByteArray#) a1 a2 a3
-{-# NOINLINE byteArrayContents# #-}
-byteArrayContents# :: ByteArray# -> Addr#
-byteArrayContents# a1 = (GHC.Prim.byteArrayContents#) a1
-{-# NOINLINE sameMutableByteArray# #-}
-sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
-sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2
-{-# NOINLINE shrinkMutableByteArray# #-}
-shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
-shrinkMutableByteArray# a1 a2 a3 = (GHC.Prim.shrinkMutableByteArray#) a1 a2 a3
-{-# NOINLINE resizeMutableByteArray# #-}
-resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
-resizeMutableByteArray# a1 a2 a3 = (GHC.Prim.resizeMutableByteArray#) a1 a2 a3
-{-# NOINLINE unsafeFreezeByteArray# #-}
-unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)
-unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2
-{-# NOINLINE sizeofByteArray# #-}
-sizeofByteArray# :: ByteArray# -> Int#
-sizeofByteArray# a1 = (GHC.Prim.sizeofByteArray#) a1
-{-# NOINLINE sizeofMutableByteArray# #-}
-sizeofMutableByteArray# :: MutableByteArray# s -> Int#
-sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1
-{-# NOINLINE indexCharArray# #-}
-indexCharArray# :: ByteArray# -> Int# -> Char#
-indexCharArray# a1 a2 = (GHC.Prim.indexCharArray#) a1 a2
-{-# NOINLINE indexWideCharArray# #-}
-indexWideCharArray# :: ByteArray# -> Int# -> Char#
-indexWideCharArray# a1 a2 = (GHC.Prim.indexWideCharArray#) a1 a2
-{-# NOINLINE indexIntArray# #-}
-indexIntArray# :: ByteArray# -> Int# -> Int#
-indexIntArray# a1 a2 = (GHC.Prim.indexIntArray#) a1 a2
-{-# NOINLINE indexWordArray# #-}
-indexWordArray# :: ByteArray# -> Int# -> Word#
-indexWordArray# a1 a2 = (GHC.Prim.indexWordArray#) a1 a2
-{-# NOINLINE indexAddrArray# #-}
-indexAddrArray# :: ByteArray# -> Int# -> Addr#
-indexAddrArray# a1 a2 = (GHC.Prim.indexAddrArray#) a1 a2
-{-# NOINLINE indexFloatArray# #-}
-indexFloatArray# :: ByteArray# -> Int# -> Float#
-indexFloatArray# a1 a2 = (GHC.Prim.indexFloatArray#) a1 a2
-{-# NOINLINE indexDoubleArray# #-}
-indexDoubleArray# :: ByteArray# -> Int# -> Double#
-indexDoubleArray# a1 a2 = (GHC.Prim.indexDoubleArray#) a1 a2
-{-# NOINLINE indexStablePtrArray# #-}
-indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
-indexStablePtrArray# a1 a2 = (GHC.Prim.indexStablePtrArray#) a1 a2
-{-# NOINLINE indexInt8Array# #-}
-indexInt8Array# :: ByteArray# -> Int# -> Int#
-indexInt8Array# a1 a2 = (GHC.Prim.indexInt8Array#) a1 a2
-{-# NOINLINE indexInt16Array# #-}
-indexInt16Array# :: ByteArray# -> Int# -> Int#
-indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2
-{-# NOINLINE indexInt32Array# #-}
-indexInt32Array# :: ByteArray# -> Int# -> Int#
-indexInt32Array# a1 a2 = (GHC.Prim.indexInt32Array#) a1 a2
-{-# NOINLINE indexInt64Array# #-}
-indexInt64Array# :: ByteArray# -> Int# -> Int#
-indexInt64Array# a1 a2 = (GHC.Prim.indexInt64Array#) a1 a2
-{-# NOINLINE indexWord8Array# #-}
-indexWord8Array# :: ByteArray# -> Int# -> Word#
-indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2
-{-# NOINLINE indexWord16Array# #-}
-indexWord16Array# :: ByteArray# -> Int# -> Word#
-indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2
-{-# NOINLINE indexWord32Array# #-}
-indexWord32Array# :: ByteArray# -> Int# -> Word#
-indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2
-{-# NOINLINE indexWord64Array# #-}
-indexWord64Array# :: ByteArray# -> Int# -> Word#
-indexWord64Array# a1 a2 = (GHC.Prim.indexWord64Array#) a1 a2
-{-# NOINLINE readCharArray# #-}
-readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
-readCharArray# a1 a2 a3 = (GHC.Prim.readCharArray#) a1 a2 a3
-{-# NOINLINE readWideCharArray# #-}
-readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
-readWideCharArray# a1 a2 a3 = (GHC.Prim.readWideCharArray#) a1 a2 a3
-{-# NOINLINE readIntArray# #-}
-readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-readIntArray# a1 a2 a3 = (GHC.Prim.readIntArray#) a1 a2 a3
-{-# NOINLINE readWordArray# #-}
-readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
-readWordArray# a1 a2 a3 = (GHC.Prim.readWordArray#) a1 a2 a3
-{-# NOINLINE readAddrArray# #-}
-readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
-readAddrArray# a1 a2 a3 = (GHC.Prim.readAddrArray#) a1 a2 a3
-{-# NOINLINE readFloatArray# #-}
-readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
-readFloatArray# a1 a2 a3 = (GHC.Prim.readFloatArray#) a1 a2 a3
-{-# NOINLINE readDoubleArray# #-}
-readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
-readDoubleArray# a1 a2 a3 = (GHC.Prim.readDoubleArray#) a1 a2 a3
-{-# NOINLINE readStablePtrArray# #-}
-readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
-readStablePtrArray# a1 a2 a3 = (GHC.Prim.readStablePtrArray#) a1 a2 a3
-{-# NOINLINE readInt8Array# #-}
-readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-readInt8Array# a1 a2 a3 = (GHC.Prim.readInt8Array#) a1 a2 a3
-{-# NOINLINE readInt16Array# #-}
-readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-readInt16Array# a1 a2 a3 = (GHC.Prim.readInt16Array#) a1 a2 a3
-{-# NOINLINE readInt32Array# #-}
-readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-readInt32Array# a1 a2 a3 = (GHC.Prim.readInt32Array#) a1 a2 a3
-{-# NOINLINE readInt64Array# #-}
-readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-readInt64Array# a1 a2 a3 = (GHC.Prim.readInt64Array#) a1 a2 a3
-{-# NOINLINE readWord8Array# #-}
-readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
-readWord8Array# a1 a2 a3 = (GHC.Prim.readWord8Array#) a1 a2 a3
-{-# NOINLINE readWord16Array# #-}
-readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
-readWord16Array# a1 a2 a3 = (GHC.Prim.readWord16Array#) a1 a2 a3
-{-# NOINLINE readWord32Array# #-}
-readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
-readWord32Array# a1 a2 a3 = (GHC.Prim.readWord32Array#) a1 a2 a3
-{-# NOINLINE readWord64Array# #-}
-readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
-readWord64Array# a1 a2 a3 = (GHC.Prim.readWord64Array#) a1 a2 a3
-{-# NOINLINE writeCharArray# #-}
-writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
-writeCharArray# a1 a2 a3 a4 = (GHC.Prim.writeCharArray#) a1 a2 a3 a4
-{-# NOINLINE writeWideCharArray# #-}
-writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
-writeWideCharArray# a1 a2 a3 a4 = (GHC.Prim.writeWideCharArray#) a1 a2 a3 a4
-{-# NOINLINE writeIntArray# #-}
-writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-writeIntArray# a1 a2 a3 a4 = (GHC.Prim.writeIntArray#) a1 a2 a3 a4
-{-# NOINLINE writeWordArray# #-}
-writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
-writeWordArray# a1 a2 a3 a4 = (GHC.Prim.writeWordArray#) a1 a2 a3 a4
-{-# NOINLINE writeAddrArray# #-}
-writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
-writeAddrArray# a1 a2 a3 a4 = (GHC.Prim.writeAddrArray#) a1 a2 a3 a4
-{-# NOINLINE writeFloatArray# #-}
-writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
-writeFloatArray# a1 a2 a3 a4 = (GHC.Prim.writeFloatArray#) a1 a2 a3 a4
-{-# NOINLINE writeDoubleArray# #-}
-writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
-writeDoubleArray# a1 a2 a3 a4 = (GHC.Prim.writeDoubleArray#) a1 a2 a3 a4
-{-# NOINLINE writeStablePtrArray# #-}
-writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
-writeStablePtrArray# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrArray#) a1 a2 a3 a4
-{-# NOINLINE writeInt8Array# #-}
-writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-writeInt8Array# a1 a2 a3 a4 = (GHC.Prim.writeInt8Array#) a1 a2 a3 a4
-{-# NOINLINE writeInt16Array# #-}
-writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-writeInt16Array# a1 a2 a3 a4 = (GHC.Prim.writeInt16Array#) a1 a2 a3 a4
-{-# NOINLINE writeInt32Array# #-}
-writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-writeInt32Array# a1 a2 a3 a4 = (GHC.Prim.writeInt32Array#) a1 a2 a3 a4
-{-# NOINLINE writeInt64Array# #-}
-writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-writeInt64Array# a1 a2 a3 a4 = (GHC.Prim.writeInt64Array#) a1 a2 a3 a4
-{-# NOINLINE writeWord8Array# #-}
-writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
-writeWord8Array# a1 a2 a3 a4 = (GHC.Prim.writeWord8Array#) a1 a2 a3 a4
-{-# NOINLINE writeWord16Array# #-}
-writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
-writeWord16Array# a1 a2 a3 a4 = (GHC.Prim.writeWord16Array#) a1 a2 a3 a4
-{-# NOINLINE writeWord32Array# #-}
-writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
-writeWord32Array# a1 a2 a3 a4 = (GHC.Prim.writeWord32Array#) a1 a2 a3 a4
-{-# NOINLINE writeWord64Array# #-}
-writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
-writeWord64Array# a1 a2 a3 a4 = (GHC.Prim.writeWord64Array#) a1 a2 a3 a4
-{-# NOINLINE copyByteArray# #-}
-copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-copyByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyByteArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE copyMutableByteArray# #-}
-copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-copyMutableByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableByteArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE copyByteArrayToAddr# #-}
-copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s
-copyByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyByteArrayToAddr#) a1 a2 a3 a4 a5
-{-# NOINLINE copyMutableByteArrayToAddr# #-}
-copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s
-copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyMutableByteArrayToAddr#) a1 a2 a3 a4 a5
-{-# NOINLINE copyAddrToByteArray# #-}
-copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-copyAddrToByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.copyAddrToByteArray#) a1 a2 a3 a4 a5
-{-# NOINLINE setByteArray# #-}
-setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
-setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5
-{-# NOINLINE atomicReadIntArray# #-}
-atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
-atomicReadIntArray# a1 a2 a3 = (GHC.Prim.atomicReadIntArray#) a1 a2 a3
-{-# NOINLINE atomicWriteIntArray# #-}
-atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
-atomicWriteIntArray# a1 a2 a3 a4 = (GHC.Prim.atomicWriteIntArray#) a1 a2 a3 a4
-{-# NOINLINE casIntArray# #-}
-casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-casIntArray# a1 a2 a3 a4 a5 = (GHC.Prim.casIntArray#) a1 a2 a3 a4 a5
-{-# NOINLINE fetchAddIntArray# #-}
-fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchAddIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAddIntArray#) a1 a2 a3 a4
-{-# NOINLINE fetchSubIntArray# #-}
-fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchSubIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchSubIntArray#) a1 a2 a3 a4
-{-# NOINLINE fetchAndIntArray# #-}
-fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchAndIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAndIntArray#) a1 a2 a3 a4
-{-# NOINLINE fetchNandIntArray# #-}
-fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchNandIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchNandIntArray#) a1 a2 a3 a4
-{-# NOINLINE fetchOrIntArray# #-}
-fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchOrIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchOrIntArray#) a1 a2 a3 a4
-{-# NOINLINE fetchXorIntArray# #-}
-fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
-fetchXorIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchXorIntArray#) a1 a2 a3 a4
-{-# NOINLINE newArrayArray# #-}
-newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)
-newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2
-{-# NOINLINE sameMutableArrayArray# #-}
-sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#
-sameMutableArrayArray# a1 a2 = (GHC.Prim.sameMutableArrayArray#) a1 a2
-{-# NOINLINE unsafeFreezeArrayArray# #-}
-unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)
-unsafeFreezeArrayArray# a1 a2 = (GHC.Prim.unsafeFreezeArrayArray#) a1 a2
-{-# NOINLINE sizeofArrayArray# #-}
-sizeofArrayArray# :: ArrayArray# -> Int#
-sizeofArrayArray# a1 = (GHC.Prim.sizeofArrayArray#) a1
-{-# NOINLINE sizeofMutableArrayArray# #-}
-sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#
-sizeofMutableArrayArray# a1 = (GHC.Prim.sizeofMutableArrayArray#) a1
-{-# NOINLINE indexByteArrayArray# #-}
-indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
-indexByteArrayArray# a1 a2 = (GHC.Prim.indexByteArrayArray#) a1 a2
-{-# NOINLINE indexArrayArrayArray# #-}
-indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
-indexArrayArrayArray# a1 a2 = (GHC.Prim.indexArrayArrayArray#) a1 a2
-{-# NOINLINE readByteArrayArray# #-}
-readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)
-readByteArrayArray# a1 a2 a3 = (GHC.Prim.readByteArrayArray#) a1 a2 a3
-{-# NOINLINE readMutableByteArrayArray# #-}
-readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
-readMutableByteArrayArray# a1 a2 a3 = (GHC.Prim.readMutableByteArrayArray#) a1 a2 a3
-{-# NOINLINE readArrayArrayArray# #-}
-readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)
-readArrayArrayArray# a1 a2 a3 = (GHC.Prim.readArrayArrayArray#) a1 a2 a3
-{-# NOINLINE readMutableArrayArrayArray# #-}
-readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)
-readMutableArrayArrayArray# a1 a2 a3 = (GHC.Prim.readMutableArrayArrayArray#) a1 a2 a3
-{-# NOINLINE writeByteArrayArray# #-}
-writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
-writeByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeByteArrayArray#) a1 a2 a3 a4
-{-# NOINLINE writeMutableByteArrayArray# #-}
-writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s
-writeMutableByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableByteArrayArray#) a1 a2 a3 a4
-{-# NOINLINE writeArrayArrayArray# #-}
-writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
-writeArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeArrayArrayArray#) a1 a2 a3 a4
-{-# NOINLINE writeMutableArrayArrayArray# #-}
-writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
-writeMutableArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableArrayArrayArray#) a1 a2 a3 a4
-{-# NOINLINE copyArrayArray# #-}
-copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
-copyArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArrayArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE copyMutableArrayArray# #-}
-copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
-copyMutableArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArrayArray#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE plusAddr# #-}
-plusAddr# :: Addr# -> Int# -> Addr#
-plusAddr# a1 a2 = (GHC.Prim.plusAddr#) a1 a2
-{-# NOINLINE minusAddr# #-}
-minusAddr# :: Addr# -> Addr# -> Int#
-minusAddr# a1 a2 = (GHC.Prim.minusAddr#) a1 a2
-{-# NOINLINE remAddr# #-}
-remAddr# :: Addr# -> Int# -> Int#
-remAddr# a1 a2 = (GHC.Prim.remAddr#) a1 a2
-{-# NOINLINE addr2Int# #-}
-addr2Int# :: Addr# -> Int#
-addr2Int# a1 = (GHC.Prim.addr2Int#) a1
-{-# NOINLINE int2Addr# #-}
-int2Addr# :: Int# -> Addr#
-int2Addr# a1 = (GHC.Prim.int2Addr#) a1
-{-# NOINLINE gtAddr# #-}
-gtAddr# :: Addr# -> Addr# -> Int#
-gtAddr# a1 a2 = (GHC.Prim.gtAddr#) a1 a2
-{-# NOINLINE geAddr# #-}
-geAddr# :: Addr# -> Addr# -> Int#
-geAddr# a1 a2 = (GHC.Prim.geAddr#) a1 a2
-{-# NOINLINE eqAddr# #-}
-eqAddr# :: Addr# -> Addr# -> Int#
-eqAddr# a1 a2 = (GHC.Prim.eqAddr#) a1 a2
-{-# NOINLINE neAddr# #-}
-neAddr# :: Addr# -> Addr# -> Int#
-neAddr# a1 a2 = (GHC.Prim.neAddr#) a1 a2
-{-# NOINLINE ltAddr# #-}
-ltAddr# :: Addr# -> Addr# -> Int#
-ltAddr# a1 a2 = (GHC.Prim.ltAddr#) a1 a2
-{-# NOINLINE leAddr# #-}
-leAddr# :: Addr# -> Addr# -> Int#
-leAddr# a1 a2 = (GHC.Prim.leAddr#) a1 a2
-{-# NOINLINE indexCharOffAddr# #-}
-indexCharOffAddr# :: Addr# -> Int# -> Char#
-indexCharOffAddr# a1 a2 = (GHC.Prim.indexCharOffAddr#) a1 a2
-{-# NOINLINE indexWideCharOffAddr# #-}
-indexWideCharOffAddr# :: Addr# -> Int# -> Char#
-indexWideCharOffAddr# a1 a2 = (GHC.Prim.indexWideCharOffAddr#) a1 a2
-{-# NOINLINE indexIntOffAddr# #-}
-indexIntOffAddr# :: Addr# -> Int# -> Int#
-indexIntOffAddr# a1 a2 = (GHC.Prim.indexIntOffAddr#) a1 a2
-{-# NOINLINE indexWordOffAddr# #-}
-indexWordOffAddr# :: Addr# -> Int# -> Word#
-indexWordOffAddr# a1 a2 = (GHC.Prim.indexWordOffAddr#) a1 a2
-{-# NOINLINE indexAddrOffAddr# #-}
-indexAddrOffAddr# :: Addr# -> Int# -> Addr#
-indexAddrOffAddr# a1 a2 = (GHC.Prim.indexAddrOffAddr#) a1 a2
-{-# NOINLINE indexFloatOffAddr# #-}
-indexFloatOffAddr# :: Addr# -> Int# -> Float#
-indexFloatOffAddr# a1 a2 = (GHC.Prim.indexFloatOffAddr#) a1 a2
-{-# NOINLINE indexDoubleOffAddr# #-}
-indexDoubleOffAddr# :: Addr# -> Int# -> Double#
-indexDoubleOffAddr# a1 a2 = (GHC.Prim.indexDoubleOffAddr#) a1 a2
-{-# NOINLINE indexStablePtrOffAddr# #-}
-indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
-indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2
-{-# NOINLINE indexInt8OffAddr# #-}
-indexInt8OffAddr# :: Addr# -> Int# -> Int#
-indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2
-{-# NOINLINE indexInt16OffAddr# #-}
-indexInt16OffAddr# :: Addr# -> Int# -> Int#
-indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2
-{-# NOINLINE indexInt32OffAddr# #-}
-indexInt32OffAddr# :: Addr# -> Int# -> Int#
-indexInt32OffAddr# a1 a2 = (GHC.Prim.indexInt32OffAddr#) a1 a2
-{-# NOINLINE indexInt64OffAddr# #-}
-indexInt64OffAddr# :: Addr# -> Int# -> Int#
-indexInt64OffAddr# a1 a2 = (GHC.Prim.indexInt64OffAddr#) a1 a2
-{-# NOINLINE indexWord8OffAddr# #-}
-indexWord8OffAddr# :: Addr# -> Int# -> Word#
-indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2
-{-# NOINLINE indexWord16OffAddr# #-}
-indexWord16OffAddr# :: Addr# -> Int# -> Word#
-indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2
-{-# NOINLINE indexWord32OffAddr# #-}
-indexWord32OffAddr# :: Addr# -> Int# -> Word#
-indexWord32OffAddr# a1 a2 = (GHC.Prim.indexWord32OffAddr#) a1 a2
-{-# NOINLINE indexWord64OffAddr# #-}
-indexWord64OffAddr# :: Addr# -> Int# -> Word#
-indexWord64OffAddr# a1 a2 = (GHC.Prim.indexWord64OffAddr#) a1 a2
-{-# NOINLINE readCharOffAddr# #-}
-readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
-readCharOffAddr# a1 a2 a3 = (GHC.Prim.readCharOffAddr#) a1 a2 a3
-{-# NOINLINE readWideCharOffAddr# #-}
-readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
-readWideCharOffAddr# a1 a2 a3 = (GHC.Prim.readWideCharOffAddr#) a1 a2 a3
-{-# NOINLINE readIntOffAddr# #-}
-readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
-readIntOffAddr# a1 a2 a3 = (GHC.Prim.readIntOffAddr#) a1 a2 a3
-{-# NOINLINE readWordOffAddr# #-}
-readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
-readWordOffAddr# a1 a2 a3 = (GHC.Prim.readWordOffAddr#) a1 a2 a3
-{-# NOINLINE readAddrOffAddr# #-}
-readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)
-readAddrOffAddr# a1 a2 a3 = (GHC.Prim.readAddrOffAddr#) a1 a2 a3
-{-# NOINLINE readFloatOffAddr# #-}
-readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)
-readFloatOffAddr# a1 a2 a3 = (GHC.Prim.readFloatOffAddr#) a1 a2 a3
-{-# NOINLINE readDoubleOffAddr# #-}
-readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)
-readDoubleOffAddr# a1 a2 a3 = (GHC.Prim.readDoubleOffAddr#) a1 a2 a3
-{-# NOINLINE readStablePtrOffAddr# #-}
-readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)
-readStablePtrOffAddr# a1 a2 a3 = (GHC.Prim.readStablePtrOffAddr#) a1 a2 a3
-{-# NOINLINE readInt8OffAddr# #-}
-readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
-readInt8OffAddr# a1 a2 a3 = (GHC.Prim.readInt8OffAddr#) a1 a2 a3
-{-# NOINLINE readInt16OffAddr# #-}
-readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
-readInt16OffAddr# a1 a2 a3 = (GHC.Prim.readInt16OffAddr#) a1 a2 a3
-{-# NOINLINE readInt32OffAddr# #-}
-readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
-readInt32OffAddr# a1 a2 a3 = (GHC.Prim.readInt32OffAddr#) a1 a2 a3
-{-# NOINLINE readInt64OffAddr# #-}
-readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
-readInt64OffAddr# a1 a2 a3 = (GHC.Prim.readInt64OffAddr#) a1 a2 a3
-{-# NOINLINE readWord8OffAddr# #-}
-readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
-readWord8OffAddr# a1 a2 a3 = (GHC.Prim.readWord8OffAddr#) a1 a2 a3
-{-# NOINLINE readWord16OffAddr# #-}
-readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
-readWord16OffAddr# a1 a2 a3 = (GHC.Prim.readWord16OffAddr#) a1 a2 a3
-{-# NOINLINE readWord32OffAddr# #-}
-readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
-readWord32OffAddr# a1 a2 a3 = (GHC.Prim.readWord32OffAddr#) a1 a2 a3
-{-# NOINLINE readWord64OffAddr# #-}
-readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
-readWord64OffAddr# a1 a2 a3 = (GHC.Prim.readWord64OffAddr#) a1 a2 a3
-{-# NOINLINE writeCharOffAddr# #-}
-writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
-writeCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeCharOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWideCharOffAddr# #-}
-writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
-writeWideCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWideCharOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeIntOffAddr# #-}
-writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
-writeIntOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeIntOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWordOffAddr# #-}
-writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
-writeWordOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWordOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeAddrOffAddr# #-}
-writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
-writeAddrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeAddrOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeFloatOffAddr# #-}
-writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
-writeFloatOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeFloatOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeDoubleOffAddr# #-}
-writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
-writeDoubleOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeDoubleOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeStablePtrOffAddr# #-}
-writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
-writeStablePtrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrOffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeInt8OffAddr# #-}
-writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
-writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeInt16OffAddr# #-}
-writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
-writeInt16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt16OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeInt32OffAddr# #-}
-writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
-writeInt32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt32OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeInt64OffAddr# #-}
-writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
-writeInt64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt64OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWord8OffAddr# #-}
-writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
-writeWord8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord8OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWord16OffAddr# #-}
-writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
-writeWord16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord16OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWord32OffAddr# #-}
-writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
-writeWord32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord32OffAddr#) a1 a2 a3 a4
-{-# NOINLINE writeWord64OffAddr# #-}
-writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
-writeWord64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord64OffAddr#) a1 a2 a3 a4
-{-# NOINLINE newMutVar# #-}
-newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)
-newMutVar# a1 a2 = (GHC.Prim.newMutVar#) a1 a2
-{-# NOINLINE readMutVar# #-}
-readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)
-readMutVar# a1 a2 = (GHC.Prim.readMutVar#) a1 a2
-{-# NOINLINE writeMutVar# #-}
-writeMutVar# :: MutVar# s a -> a -> State# s -> State# s
-writeMutVar# a1 a2 a3 = (GHC.Prim.writeMutVar#) a1 a2 a3
-{-# NOINLINE sameMutVar# #-}
-sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#
-sameMutVar# a1 a2 = (GHC.Prim.sameMutVar#) a1 a2
-{-# NOINLINE atomicModifyMutVar# #-}
-atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)
-atomicModifyMutVar# a1 a2 a3 = (GHC.Prim.atomicModifyMutVar#) a1 a2 a3
-{-# NOINLINE casMutVar# #-}
-casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)
-casMutVar# a1 a2 a3 a4 = (GHC.Prim.casMutVar#) a1 a2 a3 a4
-{-# NOINLINE catch# #-}
-catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-catch# a1 a2 a3 = (GHC.Prim.catch#) a1 a2 a3
-{-# NOINLINE raise# #-}
-raise# :: a -> b
-raise# a1 = (GHC.Prim.raise#) a1
-{-# NOINLINE raiseIO# #-}
-raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)
-raiseIO# a1 a2 = (GHC.Prim.raiseIO#) a1 a2
-{-# NOINLINE maskAsyncExceptions# #-}
-maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-maskAsyncExceptions# a1 a2 = (GHC.Prim.maskAsyncExceptions#) a1 a2
-{-# NOINLINE maskUninterruptible# #-}
-maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-maskUninterruptible# a1 a2 = (GHC.Prim.maskUninterruptible#) a1 a2
-{-# NOINLINE unmaskAsyncExceptions# #-}
-unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-unmaskAsyncExceptions# a1 a2 = (GHC.Prim.unmaskAsyncExceptions#) a1 a2
-{-# NOINLINE getMaskingState# #-}
-getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
-getMaskingState# a1 = (GHC.Prim.getMaskingState#) a1
-{-# NOINLINE atomically# #-}
-atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-atomically# a1 a2 = (GHC.Prim.atomically#) a1 a2
-{-# NOINLINE retry# #-}
-retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)
-retry# a1 = (GHC.Prim.retry#) a1
-{-# NOINLINE catchRetry# #-}
-catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-catchRetry# a1 a2 a3 = (GHC.Prim.catchRetry#) a1 a2 a3
-{-# NOINLINE catchSTM# #-}
-catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
-catchSTM# a1 a2 a3 = (GHC.Prim.catchSTM#) a1 a2 a3
-{-# NOINLINE check# #-}
-check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)
-check# a1 a2 = (GHC.Prim.check#) a1 a2
-{-# NOINLINE newTVar# #-}
-newTVar# :: a -> State# s -> (# State# s,TVar# s a #)
-newTVar# a1 a2 = (GHC.Prim.newTVar#) a1 a2
-{-# NOINLINE readTVar# #-}
-readTVar# :: TVar# s a -> State# s -> (# State# s,a #)
-readTVar# a1 a2 = (GHC.Prim.readTVar#) a1 a2
-{-# NOINLINE readTVarIO# #-}
-readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)
-readTVarIO# a1 a2 = (GHC.Prim.readTVarIO#) a1 a2
-{-# NOINLINE writeTVar# #-}
-writeTVar# :: TVar# s a -> a -> State# s -> State# s
-writeTVar# a1 a2 a3 = (GHC.Prim.writeTVar#) a1 a2 a3
-{-# NOINLINE sameTVar# #-}
-sameTVar# :: TVar# s a -> TVar# s a -> Int#
-sameTVar# a1 a2 = (GHC.Prim.sameTVar#) a1 a2
-{-# NOINLINE newMVar# #-}
-newMVar# :: State# s -> (# State# s,MVar# s a #)
-newMVar# a1 = (GHC.Prim.newMVar#) a1
-{-# NOINLINE takeMVar# #-}
-takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)
-takeMVar# a1 a2 = (GHC.Prim.takeMVar#) a1 a2
-{-# NOINLINE tryTakeMVar# #-}
-tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)
-tryTakeMVar# a1 a2 = (GHC.Prim.tryTakeMVar#) a1 a2
-{-# NOINLINE putMVar# #-}
-putMVar# :: MVar# s a -> a -> State# s -> State# s
-putMVar# a1 a2 a3 = (GHC.Prim.putMVar#) a1 a2 a3
-{-# NOINLINE tryPutMVar# #-}
-tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)
-tryPutMVar# a1 a2 a3 = (GHC.Prim.tryPutMVar#) a1 a2 a3
-{-# NOINLINE readMVar# #-}
-readMVar# :: MVar# s a -> State# s -> (# State# s,a #)
-readMVar# a1 a2 = (GHC.Prim.readMVar#) a1 a2
-{-# NOINLINE tryReadMVar# #-}
-tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)
-tryReadMVar# a1 a2 = (GHC.Prim.tryReadMVar#) a1 a2
-{-# NOINLINE sameMVar# #-}
-sameMVar# :: MVar# s a -> MVar# s a -> Int#
-sameMVar# a1 a2 = (GHC.Prim.sameMVar#) a1 a2
-{-# NOINLINE isEmptyMVar# #-}
-isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)
-isEmptyMVar# a1 a2 = (GHC.Prim.isEmptyMVar#) a1 a2
-{-# NOINLINE delay# #-}
-delay# :: Int# -> State# s -> State# s
-delay# a1 a2 = (GHC.Prim.delay#) a1 a2
-{-# NOINLINE waitRead# #-}
-waitRead# :: Int# -> State# s -> State# s
-waitRead# a1 a2 = (GHC.Prim.waitRead#) a1 a2
-{-# NOINLINE waitWrite# #-}
-waitWrite# :: Int# -> State# s -> State# s
-waitWrite# a1 a2 = (GHC.Prim.waitWrite#) a1 a2
-{-# NOINLINE fork# #-}
-fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
-fork# a1 a2 = (GHC.Prim.fork#) a1 a2
-{-# NOINLINE forkOn# #-}
-forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
-forkOn# a1 a2 a3 = (GHC.Prim.forkOn#) a1 a2 a3
-{-# NOINLINE killThread# #-}
-killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
-killThread# a1 a2 a3 = (GHC.Prim.killThread#) a1 a2 a3
-{-# NOINLINE yield# #-}
-yield# :: State# (RealWorld) -> State# (RealWorld)
-yield# a1 = (GHC.Prim.yield#) a1
-{-# NOINLINE myThreadId# #-}
-myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
-myThreadId# a1 = (GHC.Prim.myThreadId#) a1
-{-# NOINLINE labelThread# #-}
-labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
-labelThread# a1 a2 a3 = (GHC.Prim.labelThread#) a1 a2 a3
-{-# NOINLINE isCurrentThreadBound# #-}
-isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
-isCurrentThreadBound# a1 = (GHC.Prim.isCurrentThreadBound#) a1
-{-# NOINLINE noDuplicate# #-}
-noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
-noDuplicate# a1 = (GHC.Prim.noDuplicate#) a1
-{-# NOINLINE threadStatus# #-}
-threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
-threadStatus# a1 a2 = (GHC.Prim.threadStatus#) a1 a2
-{-# NOINLINE mkWeak# #-}
-mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
-mkWeak# a1 a2 a3 a4 = (GHC.Prim.mkWeak#) a1 a2 a3 a4
-{-# NOINLINE mkWeakNoFinalizer# #-}
-mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
-mkWeakNoFinalizer# a1 a2 a3 = (GHC.Prim.mkWeakNoFinalizer#) a1 a2 a3
-{-# NOINLINE addCFinalizerToWeak# #-}
-addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
-addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = (GHC.Prim.addCFinalizerToWeak#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE deRefWeak# #-}
-deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)
-deRefWeak# a1 a2 = (GHC.Prim.deRefWeak#) a1 a2
-{-# NOINLINE finalizeWeak# #-}
-finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)
-finalizeWeak# a1 a2 = (GHC.Prim.finalizeWeak#) a1 a2
-{-# NOINLINE touch# #-}
-touch# :: o -> State# (RealWorld) -> State# (RealWorld)
-touch# a1 a2 = (GHC.Prim.touch#) a1 a2
-{-# NOINLINE makeStablePtr# #-}
-makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)
-makeStablePtr# a1 a2 = (GHC.Prim.makeStablePtr#) a1 a2
-{-# NOINLINE deRefStablePtr# #-}
-deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)
-deRefStablePtr# a1 a2 = (GHC.Prim.deRefStablePtr#) a1 a2
-{-# NOINLINE eqStablePtr# #-}
-eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
-eqStablePtr# a1 a2 = (GHC.Prim.eqStablePtr#) a1 a2
-{-# NOINLINE makeStableName# #-}
-makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)
-makeStableName# a1 a2 = (GHC.Prim.makeStableName#) a1 a2
-{-# NOINLINE eqStableName# #-}
-eqStableName# :: StableName# a -> StableName# b -> Int#
-eqStableName# a1 a2 = (GHC.Prim.eqStableName#) a1 a2
-{-# NOINLINE stableNameToInt# #-}
-stableNameToInt# :: StableName# a -> Int#
-stableNameToInt# a1 = (GHC.Prim.stableNameToInt#) a1
-{-# NOINLINE reallyUnsafePtrEquality# #-}
-reallyUnsafePtrEquality# :: a -> a -> Int#
-reallyUnsafePtrEquality# a1 a2 = (GHC.Prim.reallyUnsafePtrEquality#) a1 a2
-{-# NOINLINE spark# #-}
-spark# :: a -> State# s -> (# State# s,a #)
-spark# a1 a2 = (GHC.Prim.spark#) a1 a2
-{-# NOINLINE getSpark# #-}
-getSpark# :: State# s -> (# State# s,Int#,a #)
-getSpark# a1 = (GHC.Prim.getSpark#) a1
-{-# NOINLINE numSparks# #-}
-numSparks# :: State# s -> (# State# s,Int# #)
-numSparks# a1 = (GHC.Prim.numSparks#) a1
-{-# NOINLINE dataToTag# #-}
-dataToTag# :: a -> Int#
-dataToTag# a1 = (GHC.Prim.dataToTag#) a1
-{-# NOINLINE addrToAny# #-}
-addrToAny# :: Addr# -> (# a #)
-addrToAny# a1 = (GHC.Prim.addrToAny#) a1
-{-# NOINLINE mkApUpd0# #-}
-mkApUpd0# :: BCO# -> (# a #)
-mkApUpd0# a1 = (GHC.Prim.mkApUpd0#) a1
-{-# NOINLINE newBCO# #-}
-newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)
-newBCO# a1 a2 a3 a4 a5 a6 = (GHC.Prim.newBCO#) a1 a2 a3 a4 a5 a6
-{-# NOINLINE unpackClosure# #-}
-unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)
-unpackClosure# a1 = (GHC.Prim.unpackClosure#) a1
-{-# NOINLINE getApStackVal# #-}
-getApStackVal# :: a -> Int# -> (# Int#,b #)
-getApStackVal# a1 a2 = (GHC.Prim.getApStackVal#) a1 a2
-{-# NOINLINE getCCSOf# #-}
-getCCSOf# :: a -> State# s -> (# State# s,Addr# #)
-getCCSOf# a1 a2 = (GHC.Prim.getCCSOf#) a1 a2
-{-# NOINLINE getCurrentCCS# #-}
-getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)
-getCurrentCCS# a1 a2 = (GHC.Prim.getCurrentCCS#) a1 a2
-{-# NOINLINE traceEvent# #-}
-traceEvent# :: Addr# -> State# s -> State# s
-traceEvent# a1 a2 = (GHC.Prim.traceEvent#) a1 a2
-{-# NOINLINE traceMarker# #-}
-traceMarker# :: Addr# -> State# s -> State# s
-traceMarker# a1 a2 = (GHC.Prim.traceMarker#) a1 a2
-{-# NOINLINE prefetchByteArray3# #-}
-prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s
-prefetchByteArray3# a1 a2 a3 = (GHC.Prim.prefetchByteArray3#) a1 a2 a3
-{-# NOINLINE prefetchMutableByteArray3# #-}
-prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s
-prefetchMutableByteArray3# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray3#) a1 a2 a3
-{-# NOINLINE prefetchAddr3# #-}
-prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s
-prefetchAddr3# a1 a2 a3 = (GHC.Prim.prefetchAddr3#) a1 a2 a3
-{-# NOINLINE prefetchValue3# #-}
-prefetchValue3# :: a -> State# s -> State# s
-prefetchValue3# a1 a2 = (GHC.Prim.prefetchValue3#) a1 a2
-{-# NOINLINE prefetchByteArray2# #-}
-prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s
-prefetchByteArray2# a1 a2 a3 = (GHC.Prim.prefetchByteArray2#) a1 a2 a3
-{-# NOINLINE prefetchMutableByteArray2# #-}
-prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s
-prefetchMutableByteArray2# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray2#) a1 a2 a3
-{-# NOINLINE prefetchAddr2# #-}
-prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s
-prefetchAddr2# a1 a2 a3 = (GHC.Prim.prefetchAddr2#) a1 a2 a3
-{-# NOINLINE prefetchValue2# #-}
-prefetchValue2# :: a -> State# s -> State# s
-prefetchValue2# a1 a2 = (GHC.Prim.prefetchValue2#) a1 a2
-{-# NOINLINE prefetchByteArray1# #-}
-prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s
-prefetchByteArray1# a1 a2 a3 = (GHC.Prim.prefetchByteArray1#) a1 a2 a3
-{-# NOINLINE prefetchMutableByteArray1# #-}
-prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s
-prefetchMutableByteArray1# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray1#) a1 a2 a3
-{-# NOINLINE prefetchAddr1# #-}
-prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s
-prefetchAddr1# a1 a2 a3 = (GHC.Prim.prefetchAddr1#) a1 a2 a3
-{-# NOINLINE prefetchValue1# #-}
-prefetchValue1# :: a -> State# s -> State# s
-prefetchValue1# a1 a2 = (GHC.Prim.prefetchValue1#) a1 a2
-{-# NOINLINE prefetchByteArray0# #-}
-prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s
-prefetchByteArray0# a1 a2 a3 = (GHC.Prim.prefetchByteArray0#) a1 a2 a3
-{-# NOINLINE prefetchMutableByteArray0# #-}
-prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s
-prefetchMutableByteArray0# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray0#) a1 a2 a3
-{-# NOINLINE prefetchAddr0# #-}
-prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s
-prefetchAddr0# a1 a2 a3 = (GHC.Prim.prefetchAddr0#) a1 a2 a3
-{-# NOINLINE prefetchValue0# #-}
-prefetchValue0# :: a -> State# s -> State# s
-prefetchValue0# a1 a2 = (GHC.Prim.prefetchValue0#) a1 a2
+-- | Users should not import this module. It is GHC internal only.
+-- Use "GHC.Exts" instead.
+{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-}
+{-# OPTIONS_GHC -Wno-deprecations -O0 -fno-do-eta-reduction #-}
+module GHC.PrimopWrappers where
+import qualified GHC.Prim
+import GHC.Tuple ()
+import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Int64#, Word64#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, RealWorld, MutVar#, PromptTag#, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO)
+{-# NOINLINE gtChar# #-}
+gtChar# :: Char# -> Char# -> Int#
+gtChar# a1 a2 = GHC.Prim.gtChar# a1 a2
+{-# NOINLINE geChar# #-}
+geChar# :: Char# -> Char# -> Int#
+geChar# a1 a2 = GHC.Prim.geChar# a1 a2
+{-# NOINLINE eqChar# #-}
+eqChar# :: Char# -> Char# -> Int#
+eqChar# a1 a2 = GHC.Prim.eqChar# a1 a2
+{-# NOINLINE neChar# #-}
+neChar# :: Char# -> Char# -> Int#
+neChar# a1 a2 = GHC.Prim.neChar# a1 a2
+{-# NOINLINE ltChar# #-}
+ltChar# :: Char# -> Char# -> Int#
+ltChar# a1 a2 = GHC.Prim.ltChar# a1 a2
+{-# NOINLINE leChar# #-}
+leChar# :: Char# -> Char# -> Int#
+leChar# a1 a2 = GHC.Prim.leChar# a1 a2
+{-# NOINLINE ord# #-}
+ord# :: Char# -> Int#
+ord# a1 = GHC.Prim.ord# a1
+{-# NOINLINE int8ToInt# #-}
+int8ToInt# :: Int8# -> Int#
+int8ToInt# a1 = GHC.Prim.int8ToInt# a1
+{-# NOINLINE intToInt8# #-}
+intToInt8# :: Int# -> Int8#
+intToInt8# a1 = GHC.Prim.intToInt8# a1
+{-# NOINLINE negateInt8# #-}
+negateInt8# :: Int8# -> Int8#
+negateInt8# a1 = GHC.Prim.negateInt8# a1
+{-# NOINLINE plusInt8# #-}
+plusInt8# :: Int8# -> Int8# -> Int8#
+plusInt8# a1 a2 = GHC.Prim.plusInt8# a1 a2
+{-# NOINLINE subInt8# #-}
+subInt8# :: Int8# -> Int8# -> Int8#
+subInt8# a1 a2 = GHC.Prim.subInt8# a1 a2
+{-# NOINLINE timesInt8# #-}
+timesInt8# :: Int8# -> Int8# -> Int8#
+timesInt8# a1 a2 = GHC.Prim.timesInt8# a1 a2
+{-# NOINLINE quotInt8# #-}
+quotInt8# :: Int8# -> Int8# -> Int8#
+quotInt8# a1 a2 = GHC.Prim.quotInt8# a1 a2
+{-# NOINLINE remInt8# #-}
+remInt8# :: Int8# -> Int8# -> Int8#
+remInt8# a1 a2 = GHC.Prim.remInt8# a1 a2
+{-# NOINLINE quotRemInt8# #-}
+quotRemInt8# :: Int8# -> Int8# -> (# Int8#,Int8# #)
+quotRemInt8# a1 a2 = GHC.Prim.quotRemInt8# a1 a2
+{-# NOINLINE uncheckedShiftLInt8# #-}
+uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
+uncheckedShiftLInt8# a1 a2 = GHC.Prim.uncheckedShiftLInt8# a1 a2
+{-# NOINLINE uncheckedShiftRAInt8# #-}
+uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
+uncheckedShiftRAInt8# a1 a2 = GHC.Prim.uncheckedShiftRAInt8# a1 a2
+{-# NOINLINE uncheckedShiftRLInt8# #-}
+uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
+uncheckedShiftRLInt8# a1 a2 = GHC.Prim.uncheckedShiftRLInt8# a1 a2
+{-# NOINLINE int8ToWord8# #-}
+int8ToWord8# :: Int8# -> Word8#
+int8ToWord8# a1 = GHC.Prim.int8ToWord8# a1
+{-# NOINLINE eqInt8# #-}
+eqInt8# :: Int8# -> Int8# -> Int#
+eqInt8# a1 a2 = GHC.Prim.eqInt8# a1 a2
+{-# NOINLINE geInt8# #-}
+geInt8# :: Int8# -> Int8# -> Int#
+geInt8# a1 a2 = GHC.Prim.geInt8# a1 a2
+{-# NOINLINE gtInt8# #-}
+gtInt8# :: Int8# -> Int8# -> Int#
+gtInt8# a1 a2 = GHC.Prim.gtInt8# a1 a2
+{-# NOINLINE leInt8# #-}
+leInt8# :: Int8# -> Int8# -> Int#
+leInt8# a1 a2 = GHC.Prim.leInt8# a1 a2
+{-# NOINLINE ltInt8# #-}
+ltInt8# :: Int8# -> Int8# -> Int#
+ltInt8# a1 a2 = GHC.Prim.ltInt8# a1 a2
+{-# NOINLINE neInt8# #-}
+neInt8# :: Int8# -> Int8# -> Int#
+neInt8# a1 a2 = GHC.Prim.neInt8# a1 a2
+{-# NOINLINE word8ToWord# #-}
+word8ToWord# :: Word8# -> Word#
+word8ToWord# a1 = GHC.Prim.word8ToWord# a1
+{-# NOINLINE wordToWord8# #-}
+wordToWord8# :: Word# -> Word8#
+wordToWord8# a1 = GHC.Prim.wordToWord8# a1
+{-# NOINLINE plusWord8# #-}
+plusWord8# :: Word8# -> Word8# -> Word8#
+plusWord8# a1 a2 = GHC.Prim.plusWord8# a1 a2
+{-# NOINLINE subWord8# #-}
+subWord8# :: Word8# -> Word8# -> Word8#
+subWord8# a1 a2 = GHC.Prim.subWord8# a1 a2
+{-# NOINLINE timesWord8# #-}
+timesWord8# :: Word8# -> Word8# -> Word8#
+timesWord8# a1 a2 = GHC.Prim.timesWord8# a1 a2
+{-# NOINLINE quotWord8# #-}
+quotWord8# :: Word8# -> Word8# -> Word8#
+quotWord8# a1 a2 = GHC.Prim.quotWord8# a1 a2
+{-# NOINLINE remWord8# #-}
+remWord8# :: Word8# -> Word8# -> Word8#
+remWord8# a1 a2 = GHC.Prim.remWord8# a1 a2
+{-# NOINLINE quotRemWord8# #-}
+quotRemWord8# :: Word8# -> Word8# -> (# Word8#,Word8# #)
+quotRemWord8# a1 a2 = GHC.Prim.quotRemWord8# a1 a2
+{-# NOINLINE andWord8# #-}
+andWord8# :: Word8# -> Word8# -> Word8#
+andWord8# a1 a2 = GHC.Prim.andWord8# a1 a2
+{-# NOINLINE orWord8# #-}
+orWord8# :: Word8# -> Word8# -> Word8#
+orWord8# a1 a2 = GHC.Prim.orWord8# a1 a2
+{-# NOINLINE xorWord8# #-}
+xorWord8# :: Word8# -> Word8# -> Word8#
+xorWord8# a1 a2 = GHC.Prim.xorWord8# a1 a2
+{-# NOINLINE notWord8# #-}
+notWord8# :: Word8# -> Word8#
+notWord8# a1 = GHC.Prim.notWord8# a1
+{-# NOINLINE uncheckedShiftLWord8# #-}
+uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
+uncheckedShiftLWord8# a1 a2 = GHC.Prim.uncheckedShiftLWord8# a1 a2
+{-# NOINLINE uncheckedShiftRLWord8# #-}
+uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
+uncheckedShiftRLWord8# a1 a2 = GHC.Prim.uncheckedShiftRLWord8# a1 a2
+{-# NOINLINE word8ToInt8# #-}
+word8ToInt8# :: Word8# -> Int8#
+word8ToInt8# a1 = GHC.Prim.word8ToInt8# a1
+{-# NOINLINE eqWord8# #-}
+eqWord8# :: Word8# -> Word8# -> Int#
+eqWord8# a1 a2 = GHC.Prim.eqWord8# a1 a2
+{-# NOINLINE geWord8# #-}
+geWord8# :: Word8# -> Word8# -> Int#
+geWord8# a1 a2 = GHC.Prim.geWord8# a1 a2
+{-# NOINLINE gtWord8# #-}
+gtWord8# :: Word8# -> Word8# -> Int#
+gtWord8# a1 a2 = GHC.Prim.gtWord8# a1 a2
+{-# NOINLINE leWord8# #-}
+leWord8# :: Word8# -> Word8# -> Int#
+leWord8# a1 a2 = GHC.Prim.leWord8# a1 a2
+{-# NOINLINE ltWord8# #-}
+ltWord8# :: Word8# -> Word8# -> Int#
+ltWord8# a1 a2 = GHC.Prim.ltWord8# a1 a2
+{-# NOINLINE neWord8# #-}
+neWord8# :: Word8# -> Word8# -> Int#
+neWord8# a1 a2 = GHC.Prim.neWord8# a1 a2
+{-# NOINLINE int16ToInt# #-}
+int16ToInt# :: Int16# -> Int#
+int16ToInt# a1 = GHC.Prim.int16ToInt# a1
+{-# NOINLINE intToInt16# #-}
+intToInt16# :: Int# -> Int16#
+intToInt16# a1 = GHC.Prim.intToInt16# a1
+{-# NOINLINE negateInt16# #-}
+negateInt16# :: Int16# -> Int16#
+negateInt16# a1 = GHC.Prim.negateInt16# a1
+{-# NOINLINE plusInt16# #-}
+plusInt16# :: Int16# -> Int16# -> Int16#
+plusInt16# a1 a2 = GHC.Prim.plusInt16# a1 a2
+{-# NOINLINE subInt16# #-}
+subInt16# :: Int16# -> Int16# -> Int16#
+subInt16# a1 a2 = GHC.Prim.subInt16# a1 a2
+{-# NOINLINE timesInt16# #-}
+timesInt16# :: Int16# -> Int16# -> Int16#
+timesInt16# a1 a2 = GHC.Prim.timesInt16# a1 a2
+{-# NOINLINE quotInt16# #-}
+quotInt16# :: Int16# -> Int16# -> Int16#
+quotInt16# a1 a2 = GHC.Prim.quotInt16# a1 a2
+{-# NOINLINE remInt16# #-}
+remInt16# :: Int16# -> Int16# -> Int16#
+remInt16# a1 a2 = GHC.Prim.remInt16# a1 a2
+{-# NOINLINE quotRemInt16# #-}
+quotRemInt16# :: Int16# -> Int16# -> (# Int16#,Int16# #)
+quotRemInt16# a1 a2 = GHC.Prim.quotRemInt16# a1 a2
+{-# NOINLINE uncheckedShiftLInt16# #-}
+uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
+uncheckedShiftLInt16# a1 a2 = GHC.Prim.uncheckedShiftLInt16# a1 a2
+{-# NOINLINE uncheckedShiftRAInt16# #-}
+uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
+uncheckedShiftRAInt16# a1 a2 = GHC.Prim.uncheckedShiftRAInt16# a1 a2
+{-# NOINLINE uncheckedShiftRLInt16# #-}
+uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
+uncheckedShiftRLInt16# a1 a2 = GHC.Prim.uncheckedShiftRLInt16# a1 a2
+{-# NOINLINE int16ToWord16# #-}
+int16ToWord16# :: Int16# -> Word16#
+int16ToWord16# a1 = GHC.Prim.int16ToWord16# a1
+{-# NOINLINE eqInt16# #-}
+eqInt16# :: Int16# -> Int16# -> Int#
+eqInt16# a1 a2 = GHC.Prim.eqInt16# a1 a2
+{-# NOINLINE geInt16# #-}
+geInt16# :: Int16# -> Int16# -> Int#
+geInt16# a1 a2 = GHC.Prim.geInt16# a1 a2
+{-# NOINLINE gtInt16# #-}
+gtInt16# :: Int16# -> Int16# -> Int#
+gtInt16# a1 a2 = GHC.Prim.gtInt16# a1 a2
+{-# NOINLINE leInt16# #-}
+leInt16# :: Int16# -> Int16# -> Int#
+leInt16# a1 a2 = GHC.Prim.leInt16# a1 a2
+{-# NOINLINE ltInt16# #-}
+ltInt16# :: Int16# -> Int16# -> Int#
+ltInt16# a1 a2 = GHC.Prim.ltInt16# a1 a2
+{-# NOINLINE neInt16# #-}
+neInt16# :: Int16# -> Int16# -> Int#
+neInt16# a1 a2 = GHC.Prim.neInt16# a1 a2
+{-# NOINLINE word16ToWord# #-}
+word16ToWord# :: Word16# -> Word#
+word16ToWord# a1 = GHC.Prim.word16ToWord# a1
+{-# NOINLINE wordToWord16# #-}
+wordToWord16# :: Word# -> Word16#
+wordToWord16# a1 = GHC.Prim.wordToWord16# a1
+{-# NOINLINE plusWord16# #-}
+plusWord16# :: Word16# -> Word16# -> Word16#
+plusWord16# a1 a2 = GHC.Prim.plusWord16# a1 a2
+{-# NOINLINE subWord16# #-}
+subWord16# :: Word16# -> Word16# -> Word16#
+subWord16# a1 a2 = GHC.Prim.subWord16# a1 a2
+{-# NOINLINE timesWord16# #-}
+timesWord16# :: Word16# -> Word16# -> Word16#
+timesWord16# a1 a2 = GHC.Prim.timesWord16# a1 a2
+{-# NOINLINE quotWord16# #-}
+quotWord16# :: Word16# -> Word16# -> Word16#
+quotWord16# a1 a2 = GHC.Prim.quotWord16# a1 a2
+{-# NOINLINE remWord16# #-}
+remWord16# :: Word16# -> Word16# -> Word16#
+remWord16# a1 a2 = GHC.Prim.remWord16# a1 a2
+{-# NOINLINE quotRemWord16# #-}
+quotRemWord16# :: Word16# -> Word16# -> (# Word16#,Word16# #)
+quotRemWord16# a1 a2 = GHC.Prim.quotRemWord16# a1 a2
+{-# NOINLINE andWord16# #-}
+andWord16# :: Word16# -> Word16# -> Word16#
+andWord16# a1 a2 = GHC.Prim.andWord16# a1 a2
+{-# NOINLINE orWord16# #-}
+orWord16# :: Word16# -> Word16# -> Word16#
+orWord16# a1 a2 = GHC.Prim.orWord16# a1 a2
+{-# NOINLINE xorWord16# #-}
+xorWord16# :: Word16# -> Word16# -> Word16#
+xorWord16# a1 a2 = GHC.Prim.xorWord16# a1 a2
+{-# NOINLINE notWord16# #-}
+notWord16# :: Word16# -> Word16#
+notWord16# a1 = GHC.Prim.notWord16# a1
+{-# NOINLINE uncheckedShiftLWord16# #-}
+uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
+uncheckedShiftLWord16# a1 a2 = GHC.Prim.uncheckedShiftLWord16# a1 a2
+{-# NOINLINE uncheckedShiftRLWord16# #-}
+uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
+uncheckedShiftRLWord16# a1 a2 = GHC.Prim.uncheckedShiftRLWord16# a1 a2
+{-# NOINLINE word16ToInt16# #-}
+word16ToInt16# :: Word16# -> Int16#
+word16ToInt16# a1 = GHC.Prim.word16ToInt16# a1
+{-# NOINLINE eqWord16# #-}
+eqWord16# :: Word16# -> Word16# -> Int#
+eqWord16# a1 a2 = GHC.Prim.eqWord16# a1 a2
+{-# NOINLINE geWord16# #-}
+geWord16# :: Word16# -> Word16# -> Int#
+geWord16# a1 a2 = GHC.Prim.geWord16# a1 a2
+{-# NOINLINE gtWord16# #-}
+gtWord16# :: Word16# -> Word16# -> Int#
+gtWord16# a1 a2 = GHC.Prim.gtWord16# a1 a2
+{-# NOINLINE leWord16# #-}
+leWord16# :: Word16# -> Word16# -> Int#
+leWord16# a1 a2 = GHC.Prim.leWord16# a1 a2
+{-# NOINLINE ltWord16# #-}
+ltWord16# :: Word16# -> Word16# -> Int#
+ltWord16# a1 a2 = GHC.Prim.ltWord16# a1 a2
+{-# NOINLINE neWord16# #-}
+neWord16# :: Word16# -> Word16# -> Int#
+neWord16# a1 a2 = GHC.Prim.neWord16# a1 a2
+{-# NOINLINE int32ToInt# #-}
+int32ToInt# :: Int32# -> Int#
+int32ToInt# a1 = GHC.Prim.int32ToInt# a1
+{-# NOINLINE intToInt32# #-}
+intToInt32# :: Int# -> Int32#
+intToInt32# a1 = GHC.Prim.intToInt32# a1
+{-# NOINLINE negateInt32# #-}
+negateInt32# :: Int32# -> Int32#
+negateInt32# a1 = GHC.Prim.negateInt32# a1
+{-# NOINLINE plusInt32# #-}
+plusInt32# :: Int32# -> Int32# -> Int32#
+plusInt32# a1 a2 = GHC.Prim.plusInt32# a1 a2
+{-# NOINLINE subInt32# #-}
+subInt32# :: Int32# -> Int32# -> Int32#
+subInt32# a1 a2 = GHC.Prim.subInt32# a1 a2
+{-# NOINLINE timesInt32# #-}
+timesInt32# :: Int32# -> Int32# -> Int32#
+timesInt32# a1 a2 = GHC.Prim.timesInt32# a1 a2
+{-# NOINLINE quotInt32# #-}
+quotInt32# :: Int32# -> Int32# -> Int32#
+quotInt32# a1 a2 = GHC.Prim.quotInt32# a1 a2
+{-# NOINLINE remInt32# #-}
+remInt32# :: Int32# -> Int32# -> Int32#
+remInt32# a1 a2 = GHC.Prim.remInt32# a1 a2
+{-# NOINLINE quotRemInt32# #-}
+quotRemInt32# :: Int32# -> Int32# -> (# Int32#,Int32# #)
+quotRemInt32# a1 a2 = GHC.Prim.quotRemInt32# a1 a2
+{-# NOINLINE uncheckedShiftLInt32# #-}
+uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
+uncheckedShiftLInt32# a1 a2 = GHC.Prim.uncheckedShiftLInt32# a1 a2
+{-# NOINLINE uncheckedShiftRAInt32# #-}
+uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
+uncheckedShiftRAInt32# a1 a2 = GHC.Prim.uncheckedShiftRAInt32# a1 a2
+{-# NOINLINE uncheckedShiftRLInt32# #-}
+uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
+uncheckedShiftRLInt32# a1 a2 = GHC.Prim.uncheckedShiftRLInt32# a1 a2
+{-# NOINLINE int32ToWord32# #-}
+int32ToWord32# :: Int32# -> Word32#
+int32ToWord32# a1 = GHC.Prim.int32ToWord32# a1
+{-# NOINLINE eqInt32# #-}
+eqInt32# :: Int32# -> Int32# -> Int#
+eqInt32# a1 a2 = GHC.Prim.eqInt32# a1 a2
+{-# NOINLINE geInt32# #-}
+geInt32# :: Int32# -> Int32# -> Int#
+geInt32# a1 a2 = GHC.Prim.geInt32# a1 a2
+{-# NOINLINE gtInt32# #-}
+gtInt32# :: Int32# -> Int32# -> Int#
+gtInt32# a1 a2 = GHC.Prim.gtInt32# a1 a2
+{-# NOINLINE leInt32# #-}
+leInt32# :: Int32# -> Int32# -> Int#
+leInt32# a1 a2 = GHC.Prim.leInt32# a1 a2
+{-# NOINLINE ltInt32# #-}
+ltInt32# :: Int32# -> Int32# -> Int#
+ltInt32# a1 a2 = GHC.Prim.ltInt32# a1 a2
+{-# NOINLINE neInt32# #-}
+neInt32# :: Int32# -> Int32# -> Int#
+neInt32# a1 a2 = GHC.Prim.neInt32# a1 a2
+{-# NOINLINE word32ToWord# #-}
+word32ToWord# :: Word32# -> Word#
+word32ToWord# a1 = GHC.Prim.word32ToWord# a1
+{-# NOINLINE wordToWord32# #-}
+wordToWord32# :: Word# -> Word32#
+wordToWord32# a1 = GHC.Prim.wordToWord32# a1
+{-# NOINLINE plusWord32# #-}
+plusWord32# :: Word32# -> Word32# -> Word32#
+plusWord32# a1 a2 = GHC.Prim.plusWord32# a1 a2
+{-# NOINLINE subWord32# #-}
+subWord32# :: Word32# -> Word32# -> Word32#
+subWord32# a1 a2 = GHC.Prim.subWord32# a1 a2
+{-# NOINLINE timesWord32# #-}
+timesWord32# :: Word32# -> Word32# -> Word32#
+timesWord32# a1 a2 = GHC.Prim.timesWord32# a1 a2
+{-# NOINLINE quotWord32# #-}
+quotWord32# :: Word32# -> Word32# -> Word32#
+quotWord32# a1 a2 = GHC.Prim.quotWord32# a1 a2
+{-# NOINLINE remWord32# #-}
+remWord32# :: Word32# -> Word32# -> Word32#
+remWord32# a1 a2 = GHC.Prim.remWord32# a1 a2
+{-# NOINLINE quotRemWord32# #-}
+quotRemWord32# :: Word32# -> Word32# -> (# Word32#,Word32# #)
+quotRemWord32# a1 a2 = GHC.Prim.quotRemWord32# a1 a2
+{-# NOINLINE andWord32# #-}
+andWord32# :: Word32# -> Word32# -> Word32#
+andWord32# a1 a2 = GHC.Prim.andWord32# a1 a2
+{-# NOINLINE orWord32# #-}
+orWord32# :: Word32# -> Word32# -> Word32#
+orWord32# a1 a2 = GHC.Prim.orWord32# a1 a2
+{-# NOINLINE xorWord32# #-}
+xorWord32# :: Word32# -> Word32# -> Word32#
+xorWord32# a1 a2 = GHC.Prim.xorWord32# a1 a2
+{-# NOINLINE notWord32# #-}
+notWord32# :: Word32# -> Word32#
+notWord32# a1 = GHC.Prim.notWord32# a1
+{-# NOINLINE uncheckedShiftLWord32# #-}
+uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
+uncheckedShiftLWord32# a1 a2 = GHC.Prim.uncheckedShiftLWord32# a1 a2
+{-# NOINLINE uncheckedShiftRLWord32# #-}
+uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
+uncheckedShiftRLWord32# a1 a2 = GHC.Prim.uncheckedShiftRLWord32# a1 a2
+{-# NOINLINE word32ToInt32# #-}
+word32ToInt32# :: Word32# -> Int32#
+word32ToInt32# a1 = GHC.Prim.word32ToInt32# a1
+{-# NOINLINE eqWord32# #-}
+eqWord32# :: Word32# -> Word32# -> Int#
+eqWord32# a1 a2 = GHC.Prim.eqWord32# a1 a2
+{-# NOINLINE geWord32# #-}
+geWord32# :: Word32# -> Word32# -> Int#
+geWord32# a1 a2 = GHC.Prim.geWord32# a1 a2
+{-# NOINLINE gtWord32# #-}
+gtWord32# :: Word32# -> Word32# -> Int#
+gtWord32# a1 a2 = GHC.Prim.gtWord32# a1 a2
+{-# NOINLINE leWord32# #-}
+leWord32# :: Word32# -> Word32# -> Int#
+leWord32# a1 a2 = GHC.Prim.leWord32# a1 a2
+{-# NOINLINE ltWord32# #-}
+ltWord32# :: Word32# -> Word32# -> Int#
+ltWord32# a1 a2 = GHC.Prim.ltWord32# a1 a2
+{-# NOINLINE neWord32# #-}
+neWord32# :: Word32# -> Word32# -> Int#
+neWord32# a1 a2 = GHC.Prim.neWord32# a1 a2
+{-# NOINLINE int64ToInt# #-}
+int64ToInt# :: Int64# -> Int#
+int64ToInt# a1 = GHC.Prim.int64ToInt# a1
+{-# NOINLINE intToInt64# #-}
+intToInt64# :: Int# -> Int64#
+intToInt64# a1 = GHC.Prim.intToInt64# a1
+{-# NOINLINE negateInt64# #-}
+negateInt64# :: Int64# -> Int64#
+negateInt64# a1 = GHC.Prim.negateInt64# a1
+{-# NOINLINE plusInt64# #-}
+plusInt64# :: Int64# -> Int64# -> Int64#
+plusInt64# a1 a2 = GHC.Prim.plusInt64# a1 a2
+{-# NOINLINE subInt64# #-}
+subInt64# :: Int64# -> Int64# -> Int64#
+subInt64# a1 a2 = GHC.Prim.subInt64# a1 a2
+{-# NOINLINE timesInt64# #-}
+timesInt64# :: Int64# -> Int64# -> Int64#
+timesInt64# a1 a2 = GHC.Prim.timesInt64# a1 a2
+{-# NOINLINE quotInt64# #-}
+quotInt64# :: Int64# -> Int64# -> Int64#
+quotInt64# a1 a2 = GHC.Prim.quotInt64# a1 a2
+{-# NOINLINE remInt64# #-}
+remInt64# :: Int64# -> Int64# -> Int64#
+remInt64# a1 a2 = GHC.Prim.remInt64# a1 a2
+{-# NOINLINE uncheckedIShiftL64# #-}
+uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
+uncheckedIShiftL64# a1 a2 = GHC.Prim.uncheckedIShiftL64# a1 a2
+{-# NOINLINE uncheckedIShiftRA64# #-}
+uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
+uncheckedIShiftRA64# a1 a2 = GHC.Prim.uncheckedIShiftRA64# a1 a2
+{-# NOINLINE uncheckedIShiftRL64# #-}
+uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
+uncheckedIShiftRL64# a1 a2 = GHC.Prim.uncheckedIShiftRL64# a1 a2
+{-# NOINLINE int64ToWord64# #-}
+int64ToWord64# :: Int64# -> Word64#
+int64ToWord64# a1 = GHC.Prim.int64ToWord64# a1
+{-# NOINLINE eqInt64# #-}
+eqInt64# :: Int64# -> Int64# -> Int#
+eqInt64# a1 a2 = GHC.Prim.eqInt64# a1 a2
+{-# NOINLINE geInt64# #-}
+geInt64# :: Int64# -> Int64# -> Int#
+geInt64# a1 a2 = GHC.Prim.geInt64# a1 a2
+{-# NOINLINE gtInt64# #-}
+gtInt64# :: Int64# -> Int64# -> Int#
+gtInt64# a1 a2 = GHC.Prim.gtInt64# a1 a2
+{-# NOINLINE leInt64# #-}
+leInt64# :: Int64# -> Int64# -> Int#
+leInt64# a1 a2 = GHC.Prim.leInt64# a1 a2
+{-# NOINLINE ltInt64# #-}
+ltInt64# :: Int64# -> Int64# -> Int#
+ltInt64# a1 a2 = GHC.Prim.ltInt64# a1 a2
+{-# NOINLINE neInt64# #-}
+neInt64# :: Int64# -> Int64# -> Int#
+neInt64# a1 a2 = GHC.Prim.neInt64# a1 a2
+{-# NOINLINE word64ToWord# #-}
+word64ToWord# :: Word64# -> Word#
+word64ToWord# a1 = GHC.Prim.word64ToWord# a1
+{-# NOINLINE wordToWord64# #-}
+wordToWord64# :: Word# -> Word64#
+wordToWord64# a1 = GHC.Prim.wordToWord64# a1
+{-# NOINLINE plusWord64# #-}
+plusWord64# :: Word64# -> Word64# -> Word64#
+plusWord64# a1 a2 = GHC.Prim.plusWord64# a1 a2
+{-# NOINLINE subWord64# #-}
+subWord64# :: Word64# -> Word64# -> Word64#
+subWord64# a1 a2 = GHC.Prim.subWord64# a1 a2
+{-# NOINLINE timesWord64# #-}
+timesWord64# :: Word64# -> Word64# -> Word64#
+timesWord64# a1 a2 = GHC.Prim.timesWord64# a1 a2
+{-# NOINLINE quotWord64# #-}
+quotWord64# :: Word64# -> Word64# -> Word64#
+quotWord64# a1 a2 = GHC.Prim.quotWord64# a1 a2
+{-# NOINLINE remWord64# #-}
+remWord64# :: Word64# -> Word64# -> Word64#
+remWord64# a1 a2 = GHC.Prim.remWord64# a1 a2
+{-# NOINLINE and64# #-}
+and64# :: Word64# -> Word64# -> Word64#
+and64# a1 a2 = GHC.Prim.and64# a1 a2
+{-# NOINLINE or64# #-}
+or64# :: Word64# -> Word64# -> Word64#
+or64# a1 a2 = GHC.Prim.or64# a1 a2
+{-# NOINLINE xor64# #-}
+xor64# :: Word64# -> Word64# -> Word64#
+xor64# a1 a2 = GHC.Prim.xor64# a1 a2
+{-# NOINLINE not64# #-}
+not64# :: Word64# -> Word64#
+not64# a1 = GHC.Prim.not64# a1
+{-# NOINLINE uncheckedShiftL64# #-}
+uncheckedShiftL64# :: Word64# -> Int# -> Word64#
+uncheckedShiftL64# a1 a2 = GHC.Prim.uncheckedShiftL64# a1 a2
+{-# NOINLINE uncheckedShiftRL64# #-}
+uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
+uncheckedShiftRL64# a1 a2 = GHC.Prim.uncheckedShiftRL64# a1 a2
+{-# NOINLINE word64ToInt64# #-}
+word64ToInt64# :: Word64# -> Int64#
+word64ToInt64# a1 = GHC.Prim.word64ToInt64# a1
+{-# NOINLINE eqWord64# #-}
+eqWord64# :: Word64# -> Word64# -> Int#
+eqWord64# a1 a2 = GHC.Prim.eqWord64# a1 a2
+{-# NOINLINE geWord64# #-}
+geWord64# :: Word64# -> Word64# -> Int#
+geWord64# a1 a2 = GHC.Prim.geWord64# a1 a2
+{-# NOINLINE gtWord64# #-}
+gtWord64# :: Word64# -> Word64# -> Int#
+gtWord64# a1 a2 = GHC.Prim.gtWord64# a1 a2
+{-# NOINLINE leWord64# #-}
+leWord64# :: Word64# -> Word64# -> Int#
+leWord64# a1 a2 = GHC.Prim.leWord64# a1 a2
+{-# NOINLINE ltWord64# #-}
+ltWord64# :: Word64# -> Word64# -> Int#
+ltWord64# a1 a2 = GHC.Prim.ltWord64# a1 a2
+{-# NOINLINE neWord64# #-}
+neWord64# :: Word64# -> Word64# -> Int#
+neWord64# a1 a2 = GHC.Prim.neWord64# a1 a2
+{-# NOINLINE (+#) #-}
+(+#) :: Int# -> Int# -> Int#
+(+#) a1 a2 = (GHC.Prim.+#) a1 a2
+{-# NOINLINE (-#) #-}
+(-#) :: Int# -> Int# -> Int#
+(-#) a1 a2 = (GHC.Prim.-#) a1 a2
+{-# NOINLINE (*#) #-}
+(*#) :: Int# -> Int# -> Int#
+(*#) a1 a2 = (GHC.Prim.*#) a1 a2
+{-# NOINLINE timesInt2# #-}
+timesInt2# :: Int# -> Int# -> (# Int#,Int#,Int# #)
+timesInt2# a1 a2 = GHC.Prim.timesInt2# a1 a2
+{-# NOINLINE mulIntMayOflo# #-}
+mulIntMayOflo# :: Int# -> Int# -> Int#
+mulIntMayOflo# a1 a2 = GHC.Prim.mulIntMayOflo# a1 a2
+{-# NOINLINE quotInt# #-}
+quotInt# :: Int# -> Int# -> Int#
+quotInt# a1 a2 = GHC.Prim.quotInt# a1 a2
+{-# NOINLINE remInt# #-}
+remInt# :: Int# -> Int# -> Int#
+remInt# a1 a2 = GHC.Prim.remInt# a1 a2
+{-# NOINLINE quotRemInt# #-}
+quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)
+quotRemInt# a1 a2 = GHC.Prim.quotRemInt# a1 a2
+{-# NOINLINE andI# #-}
+andI# :: Int# -> Int# -> Int#
+andI# a1 a2 = GHC.Prim.andI# a1 a2
+{-# NOINLINE orI# #-}
+orI# :: Int# -> Int# -> Int#
+orI# a1 a2 = GHC.Prim.orI# a1 a2
+{-# NOINLINE xorI# #-}
+xorI# :: Int# -> Int# -> Int#
+xorI# a1 a2 = GHC.Prim.xorI# a1 a2
+{-# NOINLINE notI# #-}
+notI# :: Int# -> Int#
+notI# a1 = GHC.Prim.notI# a1
+{-# NOINLINE negateInt# #-}
+negateInt# :: Int# -> Int#
+negateInt# a1 = GHC.Prim.negateInt# a1
+{-# NOINLINE addIntC# #-}
+addIntC# :: Int# -> Int# -> (# Int#,Int# #)
+addIntC# a1 a2 = GHC.Prim.addIntC# a1 a2
+{-# NOINLINE subIntC# #-}
+subIntC# :: Int# -> Int# -> (# Int#,Int# #)
+subIntC# a1 a2 = GHC.Prim.subIntC# a1 a2
+{-# NOINLINE (>#) #-}
+(>#) :: Int# -> Int# -> Int#
+(>#) a1 a2 = (GHC.Prim.>#) a1 a2
+{-# NOINLINE (>=#) #-}
+(>=#) :: Int# -> Int# -> Int#
+(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2
+{-# NOINLINE (==#) #-}
+(==#) :: Int# -> Int# -> Int#
+(==#) a1 a2 = (GHC.Prim.==#) a1 a2
+{-# NOINLINE (/=#) #-}
+(/=#) :: Int# -> Int# -> Int#
+(/=#) a1 a2 = (GHC.Prim./=#) a1 a2
+{-# NOINLINE (<#) #-}
+(<#) :: Int# -> Int# -> Int#
+(<#) a1 a2 = (GHC.Prim.<#) a1 a2
+{-# NOINLINE (<=#) #-}
+(<=#) :: Int# -> Int# -> Int#
+(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2
+{-# NOINLINE chr# #-}
+chr# :: Int# -> Char#
+chr# a1 = GHC.Prim.chr# a1
+{-# NOINLINE int2Word# #-}
+int2Word# :: Int# -> Word#
+int2Word# a1 = GHC.Prim.int2Word# a1
+{-# NOINLINE int2Float# #-}
+int2Float# :: Int# -> Float#
+int2Float# a1 = GHC.Prim.int2Float# a1
+{-# NOINLINE int2Double# #-}
+int2Double# :: Int# -> Double#
+int2Double# a1 = GHC.Prim.int2Double# a1
+{-# NOINLINE word2Float# #-}
+word2Float# :: Word# -> Float#
+word2Float# a1 = GHC.Prim.word2Float# a1
+{-# NOINLINE word2Double# #-}
+word2Double# :: Word# -> Double#
+word2Double# a1 = GHC.Prim.word2Double# a1
+{-# NOINLINE uncheckedIShiftL# #-}
+uncheckedIShiftL# :: Int# -> Int# -> Int#
+uncheckedIShiftL# a1 a2 = GHC.Prim.uncheckedIShiftL# a1 a2
+{-# NOINLINE uncheckedIShiftRA# #-}
+uncheckedIShiftRA# :: Int# -> Int# -> Int#
+uncheckedIShiftRA# a1 a2 = GHC.Prim.uncheckedIShiftRA# a1 a2
+{-# NOINLINE uncheckedIShiftRL# #-}
+uncheckedIShiftRL# :: Int# -> Int# -> Int#
+uncheckedIShiftRL# a1 a2 = GHC.Prim.uncheckedIShiftRL# a1 a2
+{-# NOINLINE plusWord# #-}
+plusWord# :: Word# -> Word# -> Word#
+plusWord# a1 a2 = GHC.Prim.plusWord# a1 a2
+{-# NOINLINE addWordC# #-}
+addWordC# :: Word# -> Word# -> (# Word#,Int# #)
+addWordC# a1 a2 = GHC.Prim.addWordC# a1 a2
+{-# NOINLINE subWordC# #-}
+subWordC# :: Word# -> Word# -> (# Word#,Int# #)
+subWordC# a1 a2 = GHC.Prim.subWordC# a1 a2
+{-# NOINLINE plusWord2# #-}
+plusWord2# :: Word# -> Word# -> (# Word#,Word# #)
+plusWord2# a1 a2 = GHC.Prim.plusWord2# a1 a2
+{-# NOINLINE minusWord# #-}
+minusWord# :: Word# -> Word# -> Word#
+minusWord# a1 a2 = GHC.Prim.minusWord# a1 a2
+{-# NOINLINE timesWord# #-}
+timesWord# :: Word# -> Word# -> Word#
+timesWord# a1 a2 = GHC.Prim.timesWord# a1 a2
+{-# NOINLINE timesWord2# #-}
+timesWord2# :: Word# -> Word# -> (# Word#,Word# #)
+timesWord2# a1 a2 = GHC.Prim.timesWord2# a1 a2
+{-# NOINLINE quotWord# #-}
+quotWord# :: Word# -> Word# -> Word#
+quotWord# a1 a2 = GHC.Prim.quotWord# a1 a2
+{-# NOINLINE remWord# #-}
+remWord# :: Word# -> Word# -> Word#
+remWord# a1 a2 = GHC.Prim.remWord# a1 a2
+{-# NOINLINE quotRemWord# #-}
+quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)
+quotRemWord# a1 a2 = GHC.Prim.quotRemWord# a1 a2
+{-# NOINLINE quotRemWord2# #-}
+quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)
+quotRemWord2# a1 a2 a3 = GHC.Prim.quotRemWord2# a1 a2 a3
+{-# NOINLINE and# #-}
+and# :: Word# -> Word# -> Word#
+and# a1 a2 = GHC.Prim.and# a1 a2
+{-# NOINLINE or# #-}
+or# :: Word# -> Word# -> Word#
+or# a1 a2 = GHC.Prim.or# a1 a2
+{-# NOINLINE xor# #-}
+xor# :: Word# -> Word# -> Word#
+xor# a1 a2 = GHC.Prim.xor# a1 a2
+{-# NOINLINE not# #-}
+not# :: Word# -> Word#
+not# a1 = GHC.Prim.not# a1
+{-# NOINLINE uncheckedShiftL# #-}
+uncheckedShiftL# :: Word# -> Int# -> Word#
+uncheckedShiftL# a1 a2 = GHC.Prim.uncheckedShiftL# a1 a2
+{-# NOINLINE uncheckedShiftRL# #-}
+uncheckedShiftRL# :: Word# -> Int# -> Word#
+uncheckedShiftRL# a1 a2 = GHC.Prim.uncheckedShiftRL# a1 a2
+{-# NOINLINE word2Int# #-}
+word2Int# :: Word# -> Int#
+word2Int# a1 = GHC.Prim.word2Int# a1
+{-# NOINLINE gtWord# #-}
+gtWord# :: Word# -> Word# -> Int#
+gtWord# a1 a2 = GHC.Prim.gtWord# a1 a2
+{-# NOINLINE geWord# #-}
+geWord# :: Word# -> Word# -> Int#
+geWord# a1 a2 = GHC.Prim.geWord# a1 a2
+{-# NOINLINE eqWord# #-}
+eqWord# :: Word# -> Word# -> Int#
+eqWord# a1 a2 = GHC.Prim.eqWord# a1 a2
+{-# NOINLINE neWord# #-}
+neWord# :: Word# -> Word# -> Int#
+neWord# a1 a2 = GHC.Prim.neWord# a1 a2
+{-# NOINLINE ltWord# #-}
+ltWord# :: Word# -> Word# -> Int#
+ltWord# a1 a2 = GHC.Prim.ltWord# a1 a2
+{-# NOINLINE leWord# #-}
+leWord# :: Word# -> Word# -> Int#
+leWord# a1 a2 = GHC.Prim.leWord# a1 a2
+{-# NOINLINE popCnt8# #-}
+popCnt8# :: Word# -> Word#
+popCnt8# a1 = GHC.Prim.popCnt8# a1
+{-# NOINLINE popCnt16# #-}
+popCnt16# :: Word# -> Word#
+popCnt16# a1 = GHC.Prim.popCnt16# a1
+{-# NOINLINE popCnt32# #-}
+popCnt32# :: Word# -> Word#
+popCnt32# a1 = GHC.Prim.popCnt32# a1
+{-# NOINLINE popCnt64# #-}
+popCnt64# :: Word64# -> Word#
+popCnt64# a1 = GHC.Prim.popCnt64# a1
+{-# NOINLINE popCnt# #-}
+popCnt# :: Word# -> Word#
+popCnt# a1 = GHC.Prim.popCnt# a1
+{-# NOINLINE pdep8# #-}
+pdep8# :: Word# -> Word# -> Word#
+pdep8# a1 a2 = GHC.Prim.pdep8# a1 a2
+{-# NOINLINE pdep16# #-}
+pdep16# :: Word# -> Word# -> Word#
+pdep16# a1 a2 = GHC.Prim.pdep16# a1 a2
+{-# NOINLINE pdep32# #-}
+pdep32# :: Word# -> Word# -> Word#
+pdep32# a1 a2 = GHC.Prim.pdep32# a1 a2
+{-# NOINLINE pdep64# #-}
+pdep64# :: Word64# -> Word64# -> Word64#
+pdep64# a1 a2 = GHC.Prim.pdep64# a1 a2
+{-# NOINLINE pdep# #-}
+pdep# :: Word# -> Word# -> Word#
+pdep# a1 a2 = GHC.Prim.pdep# a1 a2
+{-# NOINLINE pext8# #-}
+pext8# :: Word# -> Word# -> Word#
+pext8# a1 a2 = GHC.Prim.pext8# a1 a2
+{-# NOINLINE pext16# #-}
+pext16# :: Word# -> Word# -> Word#
+pext16# a1 a2 = GHC.Prim.pext16# a1 a2
+{-# NOINLINE pext32# #-}
+pext32# :: Word# -> Word# -> Word#
+pext32# a1 a2 = GHC.Prim.pext32# a1 a2
+{-# NOINLINE pext64# #-}
+pext64# :: Word64# -> Word64# -> Word64#
+pext64# a1 a2 = GHC.Prim.pext64# a1 a2
+{-# NOINLINE pext# #-}
+pext# :: Word# -> Word# -> Word#
+pext# a1 a2 = GHC.Prim.pext# a1 a2
+{-# NOINLINE clz8# #-}
+clz8# :: Word# -> Word#
+clz8# a1 = GHC.Prim.clz8# a1
+{-# NOINLINE clz16# #-}
+clz16# :: Word# -> Word#
+clz16# a1 = GHC.Prim.clz16# a1
+{-# NOINLINE clz32# #-}
+clz32# :: Word# -> Word#
+clz32# a1 = GHC.Prim.clz32# a1
+{-# NOINLINE clz64# #-}
+clz64# :: Word64# -> Word#
+clz64# a1 = GHC.Prim.clz64# a1
+{-# NOINLINE clz# #-}
+clz# :: Word# -> Word#
+clz# a1 = GHC.Prim.clz# a1
+{-# NOINLINE ctz8# #-}
+ctz8# :: Word# -> Word#
+ctz8# a1 = GHC.Prim.ctz8# a1
+{-# NOINLINE ctz16# #-}
+ctz16# :: Word# -> Word#
+ctz16# a1 = GHC.Prim.ctz16# a1
+{-# NOINLINE ctz32# #-}
+ctz32# :: Word# -> Word#
+ctz32# a1 = GHC.Prim.ctz32# a1
+{-# NOINLINE ctz64# #-}
+ctz64# :: Word64# -> Word#
+ctz64# a1 = GHC.Prim.ctz64# a1
+{-# NOINLINE ctz# #-}
+ctz# :: Word# -> Word#
+ctz# a1 = GHC.Prim.ctz# a1
+{-# NOINLINE byteSwap16# #-}
+byteSwap16# :: Word# -> Word#
+byteSwap16# a1 = GHC.Prim.byteSwap16# a1
+{-# NOINLINE byteSwap32# #-}
+byteSwap32# :: Word# -> Word#
+byteSwap32# a1 = GHC.Prim.byteSwap32# a1
+{-# NOINLINE byteSwap64# #-}
+byteSwap64# :: Word64# -> Word64#
+byteSwap64# a1 = GHC.Prim.byteSwap64# a1
+{-# NOINLINE byteSwap# #-}
+byteSwap# :: Word# -> Word#
+byteSwap# a1 = GHC.Prim.byteSwap# a1
+{-# NOINLINE bitReverse8# #-}
+bitReverse8# :: Word# -> Word#
+bitReverse8# a1 = GHC.Prim.bitReverse8# a1
+{-# NOINLINE bitReverse16# #-}
+bitReverse16# :: Word# -> Word#
+bitReverse16# a1 = GHC.Prim.bitReverse16# a1
+{-# NOINLINE bitReverse32# #-}
+bitReverse32# :: Word# -> Word#
+bitReverse32# a1 = GHC.Prim.bitReverse32# a1
+{-# NOINLINE bitReverse64# #-}
+bitReverse64# :: Word64# -> Word64#
+bitReverse64# a1 = GHC.Prim.bitReverse64# a1
+{-# NOINLINE bitReverse# #-}
+bitReverse# :: Word# -> Word#
+bitReverse# a1 = GHC.Prim.bitReverse# a1
+{-# NOINLINE narrow8Int# #-}
+narrow8Int# :: Int# -> Int#
+narrow8Int# a1 = GHC.Prim.narrow8Int# a1
+{-# NOINLINE narrow16Int# #-}
+narrow16Int# :: Int# -> Int#
+narrow16Int# a1 = GHC.Prim.narrow16Int# a1
+{-# NOINLINE narrow32Int# #-}
+narrow32Int# :: Int# -> Int#
+narrow32Int# a1 = GHC.Prim.narrow32Int# a1
+{-# NOINLINE narrow8Word# #-}
+narrow8Word# :: Word# -> Word#
+narrow8Word# a1 = GHC.Prim.narrow8Word# a1
+{-# NOINLINE narrow16Word# #-}
+narrow16Word# :: Word# -> Word#
+narrow16Word# a1 = GHC.Prim.narrow16Word# a1
+{-# NOINLINE narrow32Word# #-}
+narrow32Word# :: Word# -> Word#
+narrow32Word# a1 = GHC.Prim.narrow32Word# a1
+{-# NOINLINE (>##) #-}
+(>##) :: Double# -> Double# -> Int#
+(>##) a1 a2 = (GHC.Prim.>##) a1 a2
+{-# NOINLINE (>=##) #-}
+(>=##) :: Double# -> Double# -> Int#
+(>=##) a1 a2 = (GHC.Prim.>=##) a1 a2
+{-# NOINLINE (==##) #-}
+(==##) :: Double# -> Double# -> Int#
+(==##) a1 a2 = (GHC.Prim.==##) a1 a2
+{-# NOINLINE (/=##) #-}
+(/=##) :: Double# -> Double# -> Int#
+(/=##) a1 a2 = (GHC.Prim./=##) a1 a2
+{-# NOINLINE (<##) #-}
+(<##) :: Double# -> Double# -> Int#
+(<##) a1 a2 = (GHC.Prim.<##) a1 a2
+{-# NOINLINE (<=##) #-}
+(<=##) :: Double# -> Double# -> Int#
+(<=##) a1 a2 = (GHC.Prim.<=##) a1 a2
+{-# NOINLINE minDouble# #-}
+minDouble# :: Double# -> Double# -> Double#
+minDouble# a1 a2 = GHC.Prim.minDouble# a1 a2
+{-# NOINLINE maxDouble# #-}
+maxDouble# :: Double# -> Double# -> Double#
+maxDouble# a1 a2 = GHC.Prim.maxDouble# a1 a2
+{-# NOINLINE (+##) #-}
+(+##) :: Double# -> Double# -> Double#
+(+##) a1 a2 = (GHC.Prim.+##) a1 a2
+{-# NOINLINE (-##) #-}
+(-##) :: Double# -> Double# -> Double#
+(-##) a1 a2 = (GHC.Prim.-##) a1 a2
+{-# NOINLINE (*##) #-}
+(*##) :: Double# -> Double# -> Double#
+(*##) a1 a2 = (GHC.Prim.*##) a1 a2
+{-# NOINLINE (/##) #-}
+(/##) :: Double# -> Double# -> Double#
+(/##) a1 a2 = (GHC.Prim./##) a1 a2
+{-# NOINLINE negateDouble# #-}
+negateDouble# :: Double# -> Double#
+negateDouble# a1 = GHC.Prim.negateDouble# a1
+{-# NOINLINE fabsDouble# #-}
+fabsDouble# :: Double# -> Double#
+fabsDouble# a1 = GHC.Prim.fabsDouble# a1
+{-# NOINLINE double2Int# #-}
+double2Int# :: Double# -> Int#
+double2Int# a1 = GHC.Prim.double2Int# a1
+{-# NOINLINE double2Float# #-}
+double2Float# :: Double# -> Float#
+double2Float# a1 = GHC.Prim.double2Float# a1
+{-# NOINLINE expDouble# #-}
+expDouble# :: Double# -> Double#
+expDouble# a1 = GHC.Prim.expDouble# a1
+{-# NOINLINE expm1Double# #-}
+expm1Double# :: Double# -> Double#
+expm1Double# a1 = GHC.Prim.expm1Double# a1
+{-# NOINLINE logDouble# #-}
+logDouble# :: Double# -> Double#
+logDouble# a1 = GHC.Prim.logDouble# a1
+{-# NOINLINE log1pDouble# #-}
+log1pDouble# :: Double# -> Double#
+log1pDouble# a1 = GHC.Prim.log1pDouble# a1
+{-# NOINLINE sqrtDouble# #-}
+sqrtDouble# :: Double# -> Double#
+sqrtDouble# a1 = GHC.Prim.sqrtDouble# a1
+{-# NOINLINE sinDouble# #-}
+sinDouble# :: Double# -> Double#
+sinDouble# a1 = GHC.Prim.sinDouble# a1
+{-# NOINLINE cosDouble# #-}
+cosDouble# :: Double# -> Double#
+cosDouble# a1 = GHC.Prim.cosDouble# a1
+{-# NOINLINE tanDouble# #-}
+tanDouble# :: Double# -> Double#
+tanDouble# a1 = GHC.Prim.tanDouble# a1
+{-# NOINLINE asinDouble# #-}
+asinDouble# :: Double# -> Double#
+asinDouble# a1 = GHC.Prim.asinDouble# a1
+{-# NOINLINE acosDouble# #-}
+acosDouble# :: Double# -> Double#
+acosDouble# a1 = GHC.Prim.acosDouble# a1
+{-# NOINLINE atanDouble# #-}
+atanDouble# :: Double# -> Double#
+atanDouble# a1 = GHC.Prim.atanDouble# a1
+{-# NOINLINE sinhDouble# #-}
+sinhDouble# :: Double# -> Double#
+sinhDouble# a1 = GHC.Prim.sinhDouble# a1
+{-# NOINLINE coshDouble# #-}
+coshDouble# :: Double# -> Double#
+coshDouble# a1 = GHC.Prim.coshDouble# a1
+{-# NOINLINE tanhDouble# #-}
+tanhDouble# :: Double# -> Double#
+tanhDouble# a1 = GHC.Prim.tanhDouble# a1
+{-# NOINLINE asinhDouble# #-}
+asinhDouble# :: Double# -> Double#
+asinhDouble# a1 = GHC.Prim.asinhDouble# a1
+{-# NOINLINE acoshDouble# #-}
+acoshDouble# :: Double# -> Double#
+acoshDouble# a1 = GHC.Prim.acoshDouble# a1
+{-# NOINLINE atanhDouble# #-}
+atanhDouble# :: Double# -> Double#
+atanhDouble# a1 = GHC.Prim.atanhDouble# a1
+{-# NOINLINE (**##) #-}
+(**##) :: Double# -> Double# -> Double#
+(**##) a1 a2 = (GHC.Prim.**##) a1 a2
+{-# NOINLINE decodeDouble_2Int# #-}
+decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)
+decodeDouble_2Int# a1 = GHC.Prim.decodeDouble_2Int# a1
+{-# NOINLINE decodeDouble_Int64# #-}
+decodeDouble_Int64# :: Double# -> (# Int64#,Int# #)
+decodeDouble_Int64# a1 = GHC.Prim.decodeDouble_Int64# a1
+{-# NOINLINE castDoubleToWord64# #-}
+castDoubleToWord64# :: Double# -> Word64#
+castDoubleToWord64# a1 = GHC.Prim.castDoubleToWord64# a1
+{-# NOINLINE castWord64ToDouble# #-}
+castWord64ToDouble# :: Word64# -> Double#
+castWord64ToDouble# a1 = GHC.Prim.castWord64ToDouble# a1
+{-# NOINLINE gtFloat# #-}
+gtFloat# :: Float# -> Float# -> Int#
+gtFloat# a1 a2 = GHC.Prim.gtFloat# a1 a2
+{-# NOINLINE geFloat# #-}
+geFloat# :: Float# -> Float# -> Int#
+geFloat# a1 a2 = GHC.Prim.geFloat# a1 a2
+{-# NOINLINE eqFloat# #-}
+eqFloat# :: Float# -> Float# -> Int#
+eqFloat# a1 a2 = GHC.Prim.eqFloat# a1 a2
+{-# NOINLINE neFloat# #-}
+neFloat# :: Float# -> Float# -> Int#
+neFloat# a1 a2 = GHC.Prim.neFloat# a1 a2
+{-# NOINLINE ltFloat# #-}
+ltFloat# :: Float# -> Float# -> Int#
+ltFloat# a1 a2 = GHC.Prim.ltFloat# a1 a2
+{-# NOINLINE leFloat# #-}
+leFloat# :: Float# -> Float# -> Int#
+leFloat# a1 a2 = GHC.Prim.leFloat# a1 a2
+{-# NOINLINE minFloat# #-}
+minFloat# :: Float# -> Float# -> Float#
+minFloat# a1 a2 = GHC.Prim.minFloat# a1 a2
+{-# NOINLINE maxFloat# #-}
+maxFloat# :: Float# -> Float# -> Float#
+maxFloat# a1 a2 = GHC.Prim.maxFloat# a1 a2
+{-# NOINLINE plusFloat# #-}
+plusFloat# :: Float# -> Float# -> Float#
+plusFloat# a1 a2 = GHC.Prim.plusFloat# a1 a2
+{-# NOINLINE minusFloat# #-}
+minusFloat# :: Float# -> Float# -> Float#
+minusFloat# a1 a2 = GHC.Prim.minusFloat# a1 a2
+{-# NOINLINE timesFloat# #-}
+timesFloat# :: Float# -> Float# -> Float#
+timesFloat# a1 a2 = GHC.Prim.timesFloat# a1 a2
+{-# NOINLINE divideFloat# #-}
+divideFloat# :: Float# -> Float# -> Float#
+divideFloat# a1 a2 = GHC.Prim.divideFloat# a1 a2
+{-# NOINLINE negateFloat# #-}
+negateFloat# :: Float# -> Float#
+negateFloat# a1 = GHC.Prim.negateFloat# a1
+{-# NOINLINE fabsFloat# #-}
+fabsFloat# :: Float# -> Float#
+fabsFloat# a1 = GHC.Prim.fabsFloat# a1
+{-# NOINLINE float2Int# #-}
+float2Int# :: Float# -> Int#
+float2Int# a1 = GHC.Prim.float2Int# a1
+{-# NOINLINE expFloat# #-}
+expFloat# :: Float# -> Float#
+expFloat# a1 = GHC.Prim.expFloat# a1
+{-# NOINLINE expm1Float# #-}
+expm1Float# :: Float# -> Float#
+expm1Float# a1 = GHC.Prim.expm1Float# a1
+{-# NOINLINE logFloat# #-}
+logFloat# :: Float# -> Float#
+logFloat# a1 = GHC.Prim.logFloat# a1
+{-# NOINLINE log1pFloat# #-}
+log1pFloat# :: Float# -> Float#
+log1pFloat# a1 = GHC.Prim.log1pFloat# a1
+{-# NOINLINE sqrtFloat# #-}
+sqrtFloat# :: Float# -> Float#
+sqrtFloat# a1 = GHC.Prim.sqrtFloat# a1
+{-# NOINLINE sinFloat# #-}
+sinFloat# :: Float# -> Float#
+sinFloat# a1 = GHC.Prim.sinFloat# a1
+{-# NOINLINE cosFloat# #-}
+cosFloat# :: Float# -> Float#
+cosFloat# a1 = GHC.Prim.cosFloat# a1
+{-# NOINLINE tanFloat# #-}
+tanFloat# :: Float# -> Float#
+tanFloat# a1 = GHC.Prim.tanFloat# a1
+{-# NOINLINE asinFloat# #-}
+asinFloat# :: Float# -> Float#
+asinFloat# a1 = GHC.Prim.asinFloat# a1
+{-# NOINLINE acosFloat# #-}
+acosFloat# :: Float# -> Float#
+acosFloat# a1 = GHC.Prim.acosFloat# a1
+{-# NOINLINE atanFloat# #-}
+atanFloat# :: Float# -> Float#
+atanFloat# a1 = GHC.Prim.atanFloat# a1
+{-# NOINLINE sinhFloat# #-}
+sinhFloat# :: Float# -> Float#
+sinhFloat# a1 = GHC.Prim.sinhFloat# a1
+{-# NOINLINE coshFloat# #-}
+coshFloat# :: Float# -> Float#
+coshFloat# a1 = GHC.Prim.coshFloat# a1
+{-# NOINLINE tanhFloat# #-}
+tanhFloat# :: Float# -> Float#
+tanhFloat# a1 = GHC.Prim.tanhFloat# a1
+{-# NOINLINE asinhFloat# #-}
+asinhFloat# :: Float# -> Float#
+asinhFloat# a1 = GHC.Prim.asinhFloat# a1
+{-# NOINLINE acoshFloat# #-}
+acoshFloat# :: Float# -> Float#
+acoshFloat# a1 = GHC.Prim.acoshFloat# a1
+{-# NOINLINE atanhFloat# #-}
+atanhFloat# :: Float# -> Float#
+atanhFloat# a1 = GHC.Prim.atanhFloat# a1
+{-# NOINLINE powerFloat# #-}
+powerFloat# :: Float# -> Float# -> Float#
+powerFloat# a1 a2 = GHC.Prim.powerFloat# a1 a2
+{-# NOINLINE float2Double# #-}
+float2Double# :: Float# -> Double#
+float2Double# a1 = GHC.Prim.float2Double# a1
+{-# NOINLINE decodeFloat_Int# #-}
+decodeFloat_Int# :: Float# -> (# Int#,Int# #)
+decodeFloat_Int# a1 = GHC.Prim.decodeFloat_Int# a1
+{-# NOINLINE castFloatToWord32# #-}
+castFloatToWord32# :: Float# -> Word32#
+castFloatToWord32# a1 = GHC.Prim.castFloatToWord32# a1
+{-# NOINLINE castWord32ToFloat# #-}
+castWord32ToFloat# :: Word32# -> Float#
+castWord32ToFloat# a1 = GHC.Prim.castWord32ToFloat# a1
+{-# NOINLINE fmaddFloat# #-}
+fmaddFloat# :: Float# -> Float# -> Float# -> Float#
+fmaddFloat# a1 a2 a3 = GHC.Prim.fmaddFloat# a1 a2 a3
+{-# NOINLINE fmsubFloat# #-}
+fmsubFloat# :: Float# -> Float# -> Float# -> Float#
+fmsubFloat# a1 a2 a3 = GHC.Prim.fmsubFloat# a1 a2 a3
+{-# NOINLINE fnmaddFloat# #-}
+fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
+fnmaddFloat# a1 a2 a3 = GHC.Prim.fnmaddFloat# a1 a2 a3
+{-# NOINLINE fnmsubFloat# #-}
+fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
+fnmsubFloat# a1 a2 a3 = GHC.Prim.fnmsubFloat# a1 a2 a3
+{-# NOINLINE fmaddDouble# #-}
+fmaddDouble# :: Double# -> Double# -> Double# -> Double#
+fmaddDouble# a1 a2 a3 = GHC.Prim.fmaddDouble# a1 a2 a3
+{-# NOINLINE fmsubDouble# #-}
+fmsubDouble# :: Double# -> Double# -> Double# -> Double#
+fmsubDouble# a1 a2 a3 = GHC.Prim.fmsubDouble# a1 a2 a3
+{-# NOINLINE fnmaddDouble# #-}
+fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
+fnmaddDouble# a1 a2 a3 = GHC.Prim.fnmaddDouble# a1 a2 a3
+{-# NOINLINE fnmsubDouble# #-}
+fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
+fnmsubDouble# a1 a2 a3 = GHC.Prim.fnmsubDouble# a1 a2 a3
+{-# NOINLINE newArray# #-}
+newArray# :: Int# -> a_levpoly -> State# s -> (# State# s,MutableArray# s a_levpoly #)
+newArray# a1 a2 a3 = GHC.Prim.newArray# a1 a2 a3
+{-# NOINLINE readArray# #-}
+readArray# :: MutableArray# s a_levpoly -> Int# -> State# s -> (# State# s,a_levpoly #)
+readArray# a1 a2 a3 = GHC.Prim.readArray# a1 a2 a3
+{-# NOINLINE writeArray# #-}
+writeArray# :: MutableArray# s a_levpoly -> Int# -> a_levpoly -> State# s -> State# s
+writeArray# a1 a2 a3 a4 = GHC.Prim.writeArray# a1 a2 a3 a4
+{-# NOINLINE sizeofArray# #-}
+sizeofArray# :: Array# a_levpoly -> Int#
+sizeofArray# a1 = GHC.Prim.sizeofArray# a1
+{-# NOINLINE sizeofMutableArray# #-}
+sizeofMutableArray# :: MutableArray# s a_levpoly -> Int#
+sizeofMutableArray# a1 = GHC.Prim.sizeofMutableArray# a1
+{-# NOINLINE indexArray# #-}
+indexArray# :: Array# a_levpoly -> Int# -> (# a_levpoly #)
+indexArray# a1 a2 = GHC.Prim.indexArray# a1 a2
+{-# NOINLINE unsafeFreezeArray# #-}
+unsafeFreezeArray# :: MutableArray# s a_levpoly -> State# s -> (# State# s,Array# a_levpoly #)
+unsafeFreezeArray# a1 a2 = GHC.Prim.unsafeFreezeArray# a1 a2
+{-# NOINLINE unsafeThawArray# #-}
+unsafeThawArray# :: Array# a_levpoly -> State# s -> (# State# s,MutableArray# s a_levpoly #)
+unsafeThawArray# a1 a2 = GHC.Prim.unsafeThawArray# a1 a2
+{-# NOINLINE copyArray# #-}
+copyArray# :: Array# a_levpoly -> Int# -> MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s
+copyArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE copyMutableArray# #-}
+copyMutableArray# :: MutableArray# s a_levpoly -> Int# -> MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s
+copyMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE cloneArray# #-}
+cloneArray# :: Array# a_levpoly -> Int# -> Int# -> Array# a_levpoly
+cloneArray# a1 a2 a3 = GHC.Prim.cloneArray# a1 a2 a3
+{-# NOINLINE cloneMutableArray# #-}
+cloneMutableArray# :: MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a_levpoly #)
+cloneMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneMutableArray# a1 a2 a3 a4
+{-# NOINLINE freezeArray# #-}
+freezeArray# :: MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,Array# a_levpoly #)
+freezeArray# a1 a2 a3 a4 = GHC.Prim.freezeArray# a1 a2 a3 a4
+{-# NOINLINE thawArray# #-}
+thawArray# :: Array# a_levpoly -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a_levpoly #)
+thawArray# a1 a2 a3 a4 = GHC.Prim.thawArray# a1 a2 a3 a4
+{-# NOINLINE casArray# #-}
+casArray# :: MutableArray# s a_levpoly -> Int# -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #)
+casArray# a1 a2 a3 a4 a5 = GHC.Prim.casArray# a1 a2 a3 a4 a5
+{-# NOINLINE newSmallArray# #-}
+newSmallArray# :: Int# -> a_levpoly -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #)
+newSmallArray# a1 a2 a3 = GHC.Prim.newSmallArray# a1 a2 a3
+{-# NOINLINE shrinkSmallMutableArray# #-}
+shrinkSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> State# s -> State# s
+shrinkSmallMutableArray# a1 a2 a3 = GHC.Prim.shrinkSmallMutableArray# a1 a2 a3
+{-# NOINLINE readSmallArray# #-}
+readSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> State# s -> (# State# s,a_levpoly #)
+readSmallArray# a1 a2 a3 = GHC.Prim.readSmallArray# a1 a2 a3
+{-# NOINLINE writeSmallArray# #-}
+writeSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> a_levpoly -> State# s -> State# s
+writeSmallArray# a1 a2 a3 a4 = GHC.Prim.writeSmallArray# a1 a2 a3 a4
+{-# NOINLINE sizeofSmallArray# #-}
+sizeofSmallArray# :: SmallArray# a_levpoly -> Int#
+sizeofSmallArray# a1 = GHC.Prim.sizeofSmallArray# a1
+{-# NOINLINE sizeofSmallMutableArray# #-}
+sizeofSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int#
+sizeofSmallMutableArray# a1 = GHC.Prim.sizeofSmallMutableArray# a1
+{-# NOINLINE getSizeofSmallMutableArray# #-}
+getSizeofSmallMutableArray# :: SmallMutableArray# s a_levpoly -> State# s -> (# State# s,Int# #)
+getSizeofSmallMutableArray# a1 a2 = GHC.Prim.getSizeofSmallMutableArray# a1 a2
+{-# NOINLINE indexSmallArray# #-}
+indexSmallArray# :: SmallArray# a_levpoly -> Int# -> (# a_levpoly #)
+indexSmallArray# a1 a2 = GHC.Prim.indexSmallArray# a1 a2
+{-# NOINLINE unsafeFreezeSmallArray# #-}
+unsafeFreezeSmallArray# :: SmallMutableArray# s a_levpoly -> State# s -> (# State# s,SmallArray# a_levpoly #)
+unsafeFreezeSmallArray# a1 a2 = GHC.Prim.unsafeFreezeSmallArray# a1 a2
+{-# NOINLINE unsafeThawSmallArray# #-}
+unsafeThawSmallArray# :: SmallArray# a_levpoly -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #)
+unsafeThawSmallArray# a1 a2 = GHC.Prim.unsafeThawSmallArray# a1 a2
+{-# NOINLINE copySmallArray# #-}
+copySmallArray# :: SmallArray# a_levpoly -> Int# -> SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s
+copySmallArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE copySmallMutableArray# #-}
+copySmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s
+copySmallMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallMutableArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE cloneSmallArray# #-}
+cloneSmallArray# :: SmallArray# a_levpoly -> Int# -> Int# -> SmallArray# a_levpoly
+cloneSmallArray# a1 a2 a3 = GHC.Prim.cloneSmallArray# a1 a2 a3
+{-# NOINLINE cloneSmallMutableArray# #-}
+cloneSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #)
+cloneSmallMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneSmallMutableArray# a1 a2 a3 a4
+{-# NOINLINE freezeSmallArray# #-}
+freezeSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a_levpoly #)
+freezeSmallArray# a1 a2 a3 a4 = GHC.Prim.freezeSmallArray# a1 a2 a3 a4
+{-# NOINLINE thawSmallArray# #-}
+thawSmallArray# :: SmallArray# a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #)
+thawSmallArray# a1 a2 a3 a4 = GHC.Prim.thawSmallArray# a1 a2 a3 a4
+{-# NOINLINE casSmallArray# #-}
+casSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #)
+casSmallArray# a1 a2 a3 a4 a5 = GHC.Prim.casSmallArray# a1 a2 a3 a4 a5
+{-# NOINLINE newByteArray# #-}
+newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
+newByteArray# a1 a2 = GHC.Prim.newByteArray# a1 a2
+{-# NOINLINE newPinnedByteArray# #-}
+newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
+newPinnedByteArray# a1 a2 = GHC.Prim.newPinnedByteArray# a1 a2
+{-# NOINLINE newAlignedPinnedByteArray# #-}
+newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
+newAlignedPinnedByteArray# a1 a2 a3 = GHC.Prim.newAlignedPinnedByteArray# a1 a2 a3
+{-# NOINLINE isMutableByteArrayPinned# #-}
+isMutableByteArrayPinned# :: MutableByteArray# s -> Int#
+isMutableByteArrayPinned# a1 = GHC.Prim.isMutableByteArrayPinned# a1
+{-# NOINLINE isByteArrayPinned# #-}
+isByteArrayPinned# :: ByteArray# -> Int#
+isByteArrayPinned# a1 = GHC.Prim.isByteArrayPinned# a1
+{-# NOINLINE isByteArrayWeaklyPinned# #-}
+isByteArrayWeaklyPinned# :: ByteArray# -> Int#
+isByteArrayWeaklyPinned# a1 = GHC.Prim.isByteArrayWeaklyPinned# a1
+{-# NOINLINE isMutableByteArrayWeaklyPinned# #-}
+isMutableByteArrayWeaklyPinned# :: MutableByteArray# s -> Int#
+isMutableByteArrayWeaklyPinned# a1 = GHC.Prim.isMutableByteArrayWeaklyPinned# a1
+{-# NOINLINE byteArrayContents# #-}
+byteArrayContents# :: ByteArray# -> Addr#
+byteArrayContents# a1 = GHC.Prim.byteArrayContents# a1
+{-# NOINLINE mutableByteArrayContents# #-}
+mutableByteArrayContents# :: MutableByteArray# s -> Addr#
+mutableByteArrayContents# a1 = GHC.Prim.mutableByteArrayContents# a1
+{-# NOINLINE shrinkMutableByteArray# #-}
+shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
+shrinkMutableByteArray# a1 a2 a3 = GHC.Prim.shrinkMutableByteArray# a1 a2 a3
+{-# NOINLINE resizeMutableByteArray# #-}
+resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
+resizeMutableByteArray# a1 a2 a3 = GHC.Prim.resizeMutableByteArray# a1 a2 a3
+{-# NOINLINE unsafeFreezeByteArray# #-}
+unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)
+unsafeFreezeByteArray# a1 a2 = GHC.Prim.unsafeFreezeByteArray# a1 a2
+{-# NOINLINE unsafeThawByteArray# #-}
+unsafeThawByteArray# :: ByteArray# -> State# s -> (# State# s,MutableByteArray# s #)
+unsafeThawByteArray# a1 a2 = GHC.Prim.unsafeThawByteArray# a1 a2
+{-# NOINLINE sizeofByteArray# #-}
+sizeofByteArray# :: ByteArray# -> Int#
+sizeofByteArray# a1 = GHC.Prim.sizeofByteArray# a1
+{-# NOINLINE sizeofMutableByteArray# #-}
+sizeofMutableByteArray# :: MutableByteArray# s -> Int#
+sizeofMutableByteArray# a1 = GHC.Prim.sizeofMutableByteArray# a1
+{-# NOINLINE getSizeofMutableByteArray# #-}
+getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #)
+getSizeofMutableByteArray# a1 a2 = GHC.Prim.getSizeofMutableByteArray# a1 a2
+{-# NOINLINE indexCharArray# #-}
+indexCharArray# :: ByteArray# -> Int# -> Char#
+indexCharArray# a1 a2 = GHC.Prim.indexCharArray# a1 a2
+{-# NOINLINE indexWideCharArray# #-}
+indexWideCharArray# :: ByteArray# -> Int# -> Char#
+indexWideCharArray# a1 a2 = GHC.Prim.indexWideCharArray# a1 a2
+{-# NOINLINE indexIntArray# #-}
+indexIntArray# :: ByteArray# -> Int# -> Int#
+indexIntArray# a1 a2 = GHC.Prim.indexIntArray# a1 a2
+{-# NOINLINE indexWordArray# #-}
+indexWordArray# :: ByteArray# -> Int# -> Word#
+indexWordArray# a1 a2 = GHC.Prim.indexWordArray# a1 a2
+{-# NOINLINE indexAddrArray# #-}
+indexAddrArray# :: ByteArray# -> Int# -> Addr#
+indexAddrArray# a1 a2 = GHC.Prim.indexAddrArray# a1 a2
+{-# NOINLINE indexFloatArray# #-}
+indexFloatArray# :: ByteArray# -> Int# -> Float#
+indexFloatArray# a1 a2 = GHC.Prim.indexFloatArray# a1 a2
+{-# NOINLINE indexDoubleArray# #-}
+indexDoubleArray# :: ByteArray# -> Int# -> Double#
+indexDoubleArray# a1 a2 = GHC.Prim.indexDoubleArray# a1 a2
+{-# NOINLINE indexStablePtrArray# #-}
+indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
+indexStablePtrArray# a1 a2 = GHC.Prim.indexStablePtrArray# a1 a2
+{-# NOINLINE indexInt8Array# #-}
+indexInt8Array# :: ByteArray# -> Int# -> Int8#
+indexInt8Array# a1 a2 = GHC.Prim.indexInt8Array# a1 a2
+{-# NOINLINE indexWord8Array# #-}
+indexWord8Array# :: ByteArray# -> Int# -> Word8#
+indexWord8Array# a1 a2 = GHC.Prim.indexWord8Array# a1 a2
+{-# NOINLINE indexInt16Array# #-}
+indexInt16Array# :: ByteArray# -> Int# -> Int16#
+indexInt16Array# a1 a2 = GHC.Prim.indexInt16Array# a1 a2
+{-# NOINLINE indexWord16Array# #-}
+indexWord16Array# :: ByteArray# -> Int# -> Word16#
+indexWord16Array# a1 a2 = GHC.Prim.indexWord16Array# a1 a2
+{-# NOINLINE indexInt32Array# #-}
+indexInt32Array# :: ByteArray# -> Int# -> Int32#
+indexInt32Array# a1 a2 = GHC.Prim.indexInt32Array# a1 a2
+{-# NOINLINE indexWord32Array# #-}
+indexWord32Array# :: ByteArray# -> Int# -> Word32#
+indexWord32Array# a1 a2 = GHC.Prim.indexWord32Array# a1 a2
+{-# NOINLINE indexInt64Array# #-}
+indexInt64Array# :: ByteArray# -> Int# -> Int64#
+indexInt64Array# a1 a2 = GHC.Prim.indexInt64Array# a1 a2
+{-# NOINLINE indexWord64Array# #-}
+indexWord64Array# :: ByteArray# -> Int# -> Word64#
+indexWord64Array# a1 a2 = GHC.Prim.indexWord64Array# a1 a2
+{-# NOINLINE indexWord8ArrayAsChar# #-}
+indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
+indexWord8ArrayAsChar# a1 a2 = GHC.Prim.indexWord8ArrayAsChar# a1 a2
+{-# NOINLINE indexWord8ArrayAsWideChar# #-}
+indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
+indexWord8ArrayAsWideChar# a1 a2 = GHC.Prim.indexWord8ArrayAsWideChar# a1 a2
+{-# NOINLINE indexWord8ArrayAsInt# #-}
+indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
+indexWord8ArrayAsInt# a1 a2 = GHC.Prim.indexWord8ArrayAsInt# a1 a2
+{-# NOINLINE indexWord8ArrayAsWord# #-}
+indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
+indexWord8ArrayAsWord# a1 a2 = GHC.Prim.indexWord8ArrayAsWord# a1 a2
+{-# NOINLINE indexWord8ArrayAsAddr# #-}
+indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
+indexWord8ArrayAsAddr# a1 a2 = GHC.Prim.indexWord8ArrayAsAddr# a1 a2
+{-# NOINLINE indexWord8ArrayAsFloat# #-}
+indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
+indexWord8ArrayAsFloat# a1 a2 = GHC.Prim.indexWord8ArrayAsFloat# a1 a2
+{-# NOINLINE indexWord8ArrayAsDouble# #-}
+indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
+indexWord8ArrayAsDouble# a1 a2 = GHC.Prim.indexWord8ArrayAsDouble# a1 a2
+{-# NOINLINE indexWord8ArrayAsStablePtr# #-}
+indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
+indexWord8ArrayAsStablePtr# a1 a2 = GHC.Prim.indexWord8ArrayAsStablePtr# a1 a2
+{-# NOINLINE indexWord8ArrayAsInt16# #-}
+indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
+indexWord8ArrayAsInt16# a1 a2 = GHC.Prim.indexWord8ArrayAsInt16# a1 a2
+{-# NOINLINE indexWord8ArrayAsWord16# #-}
+indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
+indexWord8ArrayAsWord16# a1 a2 = GHC.Prim.indexWord8ArrayAsWord16# a1 a2
+{-# NOINLINE indexWord8ArrayAsInt32# #-}
+indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
+indexWord8ArrayAsInt32# a1 a2 = GHC.Prim.indexWord8ArrayAsInt32# a1 a2
+{-# NOINLINE indexWord8ArrayAsWord32# #-}
+indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
+indexWord8ArrayAsWord32# a1 a2 = GHC.Prim.indexWord8ArrayAsWord32# a1 a2
+{-# NOINLINE indexWord8ArrayAsInt64# #-}
+indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
+indexWord8ArrayAsInt64# a1 a2 = GHC.Prim.indexWord8ArrayAsInt64# a1 a2
+{-# NOINLINE indexWord8ArrayAsWord64# #-}
+indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
+indexWord8ArrayAsWord64# a1 a2 = GHC.Prim.indexWord8ArrayAsWord64# a1 a2
+{-# NOINLINE readCharArray# #-}
+readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
+readCharArray# a1 a2 a3 = GHC.Prim.readCharArray# a1 a2 a3
+{-# NOINLINE readWideCharArray# #-}
+readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
+readWideCharArray# a1 a2 a3 = GHC.Prim.readWideCharArray# a1 a2 a3
+{-# NOINLINE readIntArray# #-}
+readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
+readIntArray# a1 a2 a3 = GHC.Prim.readIntArray# a1 a2 a3
+{-# NOINLINE readWordArray# #-}
+readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
+readWordArray# a1 a2 a3 = GHC.Prim.readWordArray# a1 a2 a3
+{-# NOINLINE readAddrArray# #-}
+readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
+readAddrArray# a1 a2 a3 = GHC.Prim.readAddrArray# a1 a2 a3
+{-# NOINLINE readFloatArray# #-}
+readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
+readFloatArray# a1 a2 a3 = GHC.Prim.readFloatArray# a1 a2 a3
+{-# NOINLINE readDoubleArray# #-}
+readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
+readDoubleArray# a1 a2 a3 = GHC.Prim.readDoubleArray# a1 a2 a3
+{-# NOINLINE readStablePtrArray# #-}
+readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
+readStablePtrArray# a1 a2 a3 = GHC.Prim.readStablePtrArray# a1 a2 a3
+{-# NOINLINE readInt8Array# #-}
+readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8# #)
+readInt8Array# a1 a2 a3 = GHC.Prim.readInt8Array# a1 a2 a3
+{-# NOINLINE readWord8Array# #-}
+readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8# #)
+readWord8Array# a1 a2 a3 = GHC.Prim.readWord8Array# a1 a2 a3
+{-# NOINLINE readInt16Array# #-}
+readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)
+readInt16Array# a1 a2 a3 = GHC.Prim.readInt16Array# a1 a2 a3
+{-# NOINLINE readWord16Array# #-}
+readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #)
+readWord16Array# a1 a2 a3 = GHC.Prim.readWord16Array# a1 a2 a3
+{-# NOINLINE readInt32Array# #-}
+readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)
+readInt32Array# a1 a2 a3 = GHC.Prim.readInt32Array# a1 a2 a3
+{-# NOINLINE readWord32Array# #-}
+readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #)
+readWord32Array# a1 a2 a3 = GHC.Prim.readWord32Array# a1 a2 a3
+{-# NOINLINE readInt64Array# #-}
+readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)
+readInt64Array# a1 a2 a3 = GHC.Prim.readInt64Array# a1 a2 a3
+{-# NOINLINE readWord64Array# #-}
+readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #)
+readWord64Array# a1 a2 a3 = GHC.Prim.readWord64Array# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsChar# #-}
+readWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
+readWord8ArrayAsChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsChar# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsWideChar# #-}
+readWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
+readWord8ArrayAsWideChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWideChar# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsInt# #-}
+readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
+readWord8ArrayAsInt# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsWord# #-}
+readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
+readWord8ArrayAsWord# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsAddr# #-}
+readWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
+readWord8ArrayAsAddr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsAddr# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsFloat# #-}
+readWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
+readWord8ArrayAsFloat# a1 a2 a3 = GHC.Prim.readWord8ArrayAsFloat# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsDouble# #-}
+readWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
+readWord8ArrayAsDouble# a1 a2 a3 = GHC.Prim.readWord8ArrayAsDouble# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsStablePtr# #-}
+readWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
+readWord8ArrayAsStablePtr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsStablePtr# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsInt16# #-}
+readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)
+readWord8ArrayAsInt16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt16# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsWord16# #-}
+readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #)
+readWord8ArrayAsWord16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord16# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsInt32# #-}
+readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)
+readWord8ArrayAsInt32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt32# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsWord32# #-}
+readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #)
+readWord8ArrayAsWord32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord32# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsInt64# #-}
+readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)
+readWord8ArrayAsInt64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt64# a1 a2 a3
+{-# NOINLINE readWord8ArrayAsWord64# #-}
+readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #)
+readWord8ArrayAsWord64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord64# a1 a2 a3
+{-# NOINLINE writeCharArray# #-}
+writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeCharArray# a1 a2 a3 a4 = GHC.Prim.writeCharArray# a1 a2 a3 a4
+{-# NOINLINE writeWideCharArray# #-}
+writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeWideCharArray# a1 a2 a3 a4 = GHC.Prim.writeWideCharArray# a1 a2 a3 a4
+{-# NOINLINE writeIntArray# #-}
+writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeIntArray# a1 a2 a3 a4 = GHC.Prim.writeIntArray# a1 a2 a3 a4
+{-# NOINLINE writeWordArray# #-}
+writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWordArray# a1 a2 a3 a4 = GHC.Prim.writeWordArray# a1 a2 a3 a4
+{-# NOINLINE writeAddrArray# #-}
+writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
+writeAddrArray# a1 a2 a3 a4 = GHC.Prim.writeAddrArray# a1 a2 a3 a4
+{-# NOINLINE writeFloatArray# #-}
+writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
+writeFloatArray# a1 a2 a3 a4 = GHC.Prim.writeFloatArray# a1 a2 a3 a4
+{-# NOINLINE writeDoubleArray# #-}
+writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
+writeDoubleArray# a1 a2 a3 a4 = GHC.Prim.writeDoubleArray# a1 a2 a3 a4
+{-# NOINLINE writeStablePtrArray# #-}
+writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
+writeStablePtrArray# a1 a2 a3 a4 = GHC.Prim.writeStablePtrArray# a1 a2 a3 a4
+{-# NOINLINE writeInt8Array# #-}
+writeInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> State# s -> State# s
+writeInt8Array# a1 a2 a3 a4 = GHC.Prim.writeInt8Array# a1 a2 a3 a4
+{-# NOINLINE writeWord8Array# #-}
+writeWord8Array# :: MutableByteArray# s -> Int# -> Word8# -> State# s -> State# s
+writeWord8Array# a1 a2 a3 a4 = GHC.Prim.writeWord8Array# a1 a2 a3 a4
+{-# NOINLINE writeInt16Array# #-}
+writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
+writeInt16Array# a1 a2 a3 a4 = GHC.Prim.writeInt16Array# a1 a2 a3 a4
+{-# NOINLINE writeWord16Array# #-}
+writeWord16Array# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
+writeWord16Array# a1 a2 a3 a4 = GHC.Prim.writeWord16Array# a1 a2 a3 a4
+{-# NOINLINE writeInt32Array# #-}
+writeInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
+writeInt32Array# a1 a2 a3 a4 = GHC.Prim.writeInt32Array# a1 a2 a3 a4
+{-# NOINLINE writeWord32Array# #-}
+writeWord32Array# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
+writeWord32Array# a1 a2 a3 a4 = GHC.Prim.writeWord32Array# a1 a2 a3 a4
+{-# NOINLINE writeInt64Array# #-}
+writeInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
+writeInt64Array# a1 a2 a3 a4 = GHC.Prim.writeInt64Array# a1 a2 a3 a4
+{-# NOINLINE writeWord64Array# #-}
+writeWord64Array# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
+writeWord64Array# a1 a2 a3 a4 = GHC.Prim.writeWord64Array# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsChar# #-}
+writeWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeWord8ArrayAsChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsChar# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsWideChar# #-}
+writeWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+writeWord8ArrayAsWideChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWideChar# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsInt# #-}
+writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+writeWord8ArrayAsInt# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsWord# #-}
+writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+writeWord8ArrayAsWord# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsAddr# #-}
+writeWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
+writeWord8ArrayAsAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsFloat# #-}
+writeWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
+writeWord8ArrayAsFloat# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsFloat# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsDouble# #-}
+writeWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
+writeWord8ArrayAsDouble# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsDouble# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsStablePtr# #-}
+writeWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
+writeWord8ArrayAsStablePtr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsStablePtr# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsInt16# #-}
+writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
+writeWord8ArrayAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt16# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsWord16# #-}
+writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
+writeWord8ArrayAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord16# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsInt32# #-}
+writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
+writeWord8ArrayAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt32# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsWord32# #-}
+writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
+writeWord8ArrayAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord32# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsInt64# #-}
+writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
+writeWord8ArrayAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt64# a1 a2 a3 a4
+{-# NOINLINE writeWord8ArrayAsWord64# #-}
+writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
+writeWord8ArrayAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord64# a1 a2 a3 a4
+{-# NOINLINE compareByteArrays# #-}
+compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
+compareByteArrays# a1 a2 a3 a4 a5 = GHC.Prim.compareByteArrays# a1 a2 a3 a4 a5
+{-# NOINLINE copyByteArray# #-}
+copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+copyByteArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyByteArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE copyMutableByteArray# #-}
+copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+copyMutableByteArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArray# a1 a2 a3 a4 a5 a6
+{-# NOINLINE copyMutableByteArrayNonOverlapping# #-}
+copyMutableByteArrayNonOverlapping# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6
+{-# NOINLINE copyByteArrayToAddr# #-}
+copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s
+copyByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyByteArrayToAddr# a1 a2 a3 a4 a5
+{-# NOINLINE copyMutableByteArrayToAddr# #-}
+copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s
+copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyMutableByteArrayToAddr# a1 a2 a3 a4 a5
+{-# NOINLINE copyAddrToByteArray# #-}
+copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+copyAddrToByteArray# a1 a2 a3 a4 a5 = GHC.Prim.copyAddrToByteArray# a1 a2 a3 a4 a5
+{-# NOINLINE copyAddrToAddr# #-}
+copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld)
+copyAddrToAddr# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddr# a1 a2 a3 a4
+{-# NOINLINE copyAddrToAddrNonOverlapping# #-}
+copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld)
+copyAddrToAddrNonOverlapping# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddrNonOverlapping# a1 a2 a3 a4
+{-# NOINLINE setByteArray# #-}
+setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
+setByteArray# a1 a2 a3 a4 a5 = GHC.Prim.setByteArray# a1 a2 a3 a4 a5
+{-# NOINLINE setAddrRange# #-}
+setAddrRange# :: Addr# -> Int# -> Int# -> State# (RealWorld) -> State# (RealWorld)
+setAddrRange# a1 a2 a3 a4 = GHC.Prim.setAddrRange# a1 a2 a3 a4
+{-# NOINLINE atomicReadIntArray# #-}
+atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
+atomicReadIntArray# a1 a2 a3 = GHC.Prim.atomicReadIntArray# a1 a2 a3
+{-# NOINLINE atomicWriteIntArray# #-}
+atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+atomicWriteIntArray# a1 a2 a3 a4 = GHC.Prim.atomicWriteIntArray# a1 a2 a3 a4
+{-# NOINLINE casIntArray# #-}
+casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+casIntArray# a1 a2 a3 a4 a5 = GHC.Prim.casIntArray# a1 a2 a3 a4 a5
+{-# NOINLINE casInt8Array# #-}
+casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s,Int8# #)
+casInt8Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt8Array# a1 a2 a3 a4 a5
+{-# NOINLINE casInt16Array# #-}
+casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s,Int16# #)
+casInt16Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt16Array# a1 a2 a3 a4 a5
+{-# NOINLINE casInt32Array# #-}
+casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s,Int32# #)
+casInt32Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt32Array# a1 a2 a3 a4 a5
+{-# NOINLINE casInt64Array# #-}
+casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s,Int64# #)
+casInt64Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt64Array# a1 a2 a3 a4 a5
+{-# NOINLINE fetchAddIntArray# #-}
+fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchAddIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAddIntArray# a1 a2 a3 a4
+{-# NOINLINE fetchSubIntArray# #-}
+fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchSubIntArray# a1 a2 a3 a4 = GHC.Prim.fetchSubIntArray# a1 a2 a3 a4
+{-# NOINLINE fetchAndIntArray# #-}
+fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchAndIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAndIntArray# a1 a2 a3 a4
+{-# NOINLINE fetchNandIntArray# #-}
+fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchNandIntArray# a1 a2 a3 a4 = GHC.Prim.fetchNandIntArray# a1 a2 a3 a4
+{-# NOINLINE fetchOrIntArray# #-}
+fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchOrIntArray# a1 a2 a3 a4 = GHC.Prim.fetchOrIntArray# a1 a2 a3 a4
+{-# NOINLINE fetchXorIntArray# #-}
+fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
+fetchXorIntArray# a1 a2 a3 a4 = GHC.Prim.fetchXorIntArray# a1 a2 a3 a4
+{-# NOINLINE plusAddr# #-}
+plusAddr# :: Addr# -> Int# -> Addr#
+plusAddr# a1 a2 = GHC.Prim.plusAddr# a1 a2
+{-# NOINLINE minusAddr# #-}
+minusAddr# :: Addr# -> Addr# -> Int#
+minusAddr# a1 a2 = GHC.Prim.minusAddr# a1 a2
+{-# NOINLINE remAddr# #-}
+remAddr# :: Addr# -> Int# -> Int#
+remAddr# a1 a2 = GHC.Prim.remAddr# a1 a2
+{-# NOINLINE addr2Int# #-}
+addr2Int# :: Addr# -> Int#
+addr2Int# a1 = GHC.Prim.addr2Int# a1
+{-# NOINLINE int2Addr# #-}
+int2Addr# :: Int# -> Addr#
+int2Addr# a1 = GHC.Prim.int2Addr# a1
+{-# NOINLINE gtAddr# #-}
+gtAddr# :: Addr# -> Addr# -> Int#
+gtAddr# a1 a2 = GHC.Prim.gtAddr# a1 a2
+{-# NOINLINE geAddr# #-}
+geAddr# :: Addr# -> Addr# -> Int#
+geAddr# a1 a2 = GHC.Prim.geAddr# a1 a2
+{-# NOINLINE eqAddr# #-}
+eqAddr# :: Addr# -> Addr# -> Int#
+eqAddr# a1 a2 = GHC.Prim.eqAddr# a1 a2
+{-# NOINLINE neAddr# #-}
+neAddr# :: Addr# -> Addr# -> Int#
+neAddr# a1 a2 = GHC.Prim.neAddr# a1 a2
+{-# NOINLINE ltAddr# #-}
+ltAddr# :: Addr# -> Addr# -> Int#
+ltAddr# a1 a2 = GHC.Prim.ltAddr# a1 a2
+{-# NOINLINE leAddr# #-}
+leAddr# :: Addr# -> Addr# -> Int#
+leAddr# a1 a2 = GHC.Prim.leAddr# a1 a2
+{-# NOINLINE indexCharOffAddr# #-}
+indexCharOffAddr# :: Addr# -> Int# -> Char#
+indexCharOffAddr# a1 a2 = GHC.Prim.indexCharOffAddr# a1 a2
+{-# NOINLINE indexWideCharOffAddr# #-}
+indexWideCharOffAddr# :: Addr# -> Int# -> Char#
+indexWideCharOffAddr# a1 a2 = GHC.Prim.indexWideCharOffAddr# a1 a2
+{-# NOINLINE indexIntOffAddr# #-}
+indexIntOffAddr# :: Addr# -> Int# -> Int#
+indexIntOffAddr# a1 a2 = GHC.Prim.indexIntOffAddr# a1 a2
+{-# NOINLINE indexWordOffAddr# #-}
+indexWordOffAddr# :: Addr# -> Int# -> Word#
+indexWordOffAddr# a1 a2 = GHC.Prim.indexWordOffAddr# a1 a2
+{-# NOINLINE indexAddrOffAddr# #-}
+indexAddrOffAddr# :: Addr# -> Int# -> Addr#
+indexAddrOffAddr# a1 a2 = GHC.Prim.indexAddrOffAddr# a1 a2
+{-# NOINLINE indexFloatOffAddr# #-}
+indexFloatOffAddr# :: Addr# -> Int# -> Float#
+indexFloatOffAddr# a1 a2 = GHC.Prim.indexFloatOffAddr# a1 a2
+{-# NOINLINE indexDoubleOffAddr# #-}
+indexDoubleOffAddr# :: Addr# -> Int# -> Double#
+indexDoubleOffAddr# a1 a2 = GHC.Prim.indexDoubleOffAddr# a1 a2
+{-# NOINLINE indexStablePtrOffAddr# #-}
+indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
+indexStablePtrOffAddr# a1 a2 = GHC.Prim.indexStablePtrOffAddr# a1 a2
+{-# NOINLINE indexInt8OffAddr# #-}
+indexInt8OffAddr# :: Addr# -> Int# -> Int8#
+indexInt8OffAddr# a1 a2 = GHC.Prim.indexInt8OffAddr# a1 a2
+{-# NOINLINE indexWord8OffAddr# #-}
+indexWord8OffAddr# :: Addr# -> Int# -> Word8#
+indexWord8OffAddr# a1 a2 = GHC.Prim.indexWord8OffAddr# a1 a2
+{-# NOINLINE indexInt16OffAddr# #-}
+indexInt16OffAddr# :: Addr# -> Int# -> Int16#
+indexInt16OffAddr# a1 a2 = GHC.Prim.indexInt16OffAddr# a1 a2
+{-# NOINLINE indexWord16OffAddr# #-}
+indexWord16OffAddr# :: Addr# -> Int# -> Word16#
+indexWord16OffAddr# a1 a2 = GHC.Prim.indexWord16OffAddr# a1 a2
+{-# NOINLINE indexInt32OffAddr# #-}
+indexInt32OffAddr# :: Addr# -> Int# -> Int32#
+indexInt32OffAddr# a1 a2 = GHC.Prim.indexInt32OffAddr# a1 a2
+{-# NOINLINE indexWord32OffAddr# #-}
+indexWord32OffAddr# :: Addr# -> Int# -> Word32#
+indexWord32OffAddr# a1 a2 = GHC.Prim.indexWord32OffAddr# a1 a2
+{-# NOINLINE indexInt64OffAddr# #-}
+indexInt64OffAddr# :: Addr# -> Int# -> Int64#
+indexInt64OffAddr# a1 a2 = GHC.Prim.indexInt64OffAddr# a1 a2
+{-# NOINLINE indexWord64OffAddr# #-}
+indexWord64OffAddr# :: Addr# -> Int# -> Word64#
+indexWord64OffAddr# a1 a2 = GHC.Prim.indexWord64OffAddr# a1 a2
+{-# NOINLINE indexWord8OffAddrAsChar# #-}
+indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
+indexWord8OffAddrAsChar# a1 a2 = GHC.Prim.indexWord8OffAddrAsChar# a1 a2
+{-# NOINLINE indexWord8OffAddrAsWideChar# #-}
+indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
+indexWord8OffAddrAsWideChar# a1 a2 = GHC.Prim.indexWord8OffAddrAsWideChar# a1 a2
+{-# NOINLINE indexWord8OffAddrAsInt# #-}
+indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
+indexWord8OffAddrAsInt# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt# a1 a2
+{-# NOINLINE indexWord8OffAddrAsWord# #-}
+indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
+indexWord8OffAddrAsWord# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord# a1 a2
+{-# NOINLINE indexWord8OffAddrAsAddr# #-}
+indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
+indexWord8OffAddrAsAddr# a1 a2 = GHC.Prim.indexWord8OffAddrAsAddr# a1 a2
+{-# NOINLINE indexWord8OffAddrAsFloat# #-}
+indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
+indexWord8OffAddrAsFloat# a1 a2 = GHC.Prim.indexWord8OffAddrAsFloat# a1 a2
+{-# NOINLINE indexWord8OffAddrAsDouble# #-}
+indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
+indexWord8OffAddrAsDouble# a1 a2 = GHC.Prim.indexWord8OffAddrAsDouble# a1 a2
+{-# NOINLINE indexWord8OffAddrAsStablePtr# #-}
+indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a
+indexWord8OffAddrAsStablePtr# a1 a2 = GHC.Prim.indexWord8OffAddrAsStablePtr# a1 a2
+{-# NOINLINE indexWord8OffAddrAsInt16# #-}
+indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
+indexWord8OffAddrAsInt16# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt16# a1 a2
+{-# NOINLINE indexWord8OffAddrAsWord16# #-}
+indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
+indexWord8OffAddrAsWord16# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord16# a1 a2
+{-# NOINLINE indexWord8OffAddrAsInt32# #-}
+indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
+indexWord8OffAddrAsInt32# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt32# a1 a2
+{-# NOINLINE indexWord8OffAddrAsWord32# #-}
+indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
+indexWord8OffAddrAsWord32# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord32# a1 a2
+{-# NOINLINE indexWord8OffAddrAsInt64# #-}
+indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
+indexWord8OffAddrAsInt64# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt64# a1 a2
+{-# NOINLINE indexWord8OffAddrAsWord64# #-}
+indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
+indexWord8OffAddrAsWord64# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord64# a1 a2
+{-# NOINLINE readCharOffAddr# #-}
+readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
+readCharOffAddr# a1 a2 a3 = GHC.Prim.readCharOffAddr# a1 a2 a3
+{-# NOINLINE readWideCharOffAddr# #-}
+readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
+readWideCharOffAddr# a1 a2 a3 = GHC.Prim.readWideCharOffAddr# a1 a2 a3
+{-# NOINLINE readIntOffAddr# #-}
+readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
+readIntOffAddr# a1 a2 a3 = GHC.Prim.readIntOffAddr# a1 a2 a3
+{-# NOINLINE readWordOffAddr# #-}
+readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
+readWordOffAddr# a1 a2 a3 = GHC.Prim.readWordOffAddr# a1 a2 a3
+{-# NOINLINE readAddrOffAddr# #-}
+readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)
+readAddrOffAddr# a1 a2 a3 = GHC.Prim.readAddrOffAddr# a1 a2 a3
+{-# NOINLINE readFloatOffAddr# #-}
+readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)
+readFloatOffAddr# a1 a2 a3 = GHC.Prim.readFloatOffAddr# a1 a2 a3
+{-# NOINLINE readDoubleOffAddr# #-}
+readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)
+readDoubleOffAddr# a1 a2 a3 = GHC.Prim.readDoubleOffAddr# a1 a2 a3
+{-# NOINLINE readStablePtrOffAddr# #-}
+readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)
+readStablePtrOffAddr# a1 a2 a3 = GHC.Prim.readStablePtrOffAddr# a1 a2 a3
+{-# NOINLINE readInt8OffAddr# #-}
+readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8# #)
+readInt8OffAddr# a1 a2 a3 = GHC.Prim.readInt8OffAddr# a1 a2 a3
+{-# NOINLINE readWord8OffAddr# #-}
+readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8# #)
+readWord8OffAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddr# a1 a2 a3
+{-# NOINLINE readInt16OffAddr# #-}
+readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #)
+readInt16OffAddr# a1 a2 a3 = GHC.Prim.readInt16OffAddr# a1 a2 a3
+{-# NOINLINE readWord16OffAddr# #-}
+readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #)
+readWord16OffAddr# a1 a2 a3 = GHC.Prim.readWord16OffAddr# a1 a2 a3
+{-# NOINLINE readInt32OffAddr# #-}
+readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #)
+readInt32OffAddr# a1 a2 a3 = GHC.Prim.readInt32OffAddr# a1 a2 a3
+{-# NOINLINE readWord32OffAddr# #-}
+readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #)
+readWord32OffAddr# a1 a2 a3 = GHC.Prim.readWord32OffAddr# a1 a2 a3
+{-# NOINLINE readInt64OffAddr# #-}
+readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #)
+readInt64OffAddr# a1 a2 a3 = GHC.Prim.readInt64OffAddr# a1 a2 a3
+{-# NOINLINE readWord64OffAddr# #-}
+readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #)
+readWord64OffAddr# a1 a2 a3 = GHC.Prim.readWord64OffAddr# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsChar# #-}
+readWord8OffAddrAsChar# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
+readWord8OffAddrAsChar# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsChar# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsWideChar# #-}
+readWord8OffAddrAsWideChar# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
+readWord8OffAddrAsWideChar# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWideChar# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsInt# #-}
+readWord8OffAddrAsInt# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
+readWord8OffAddrAsInt# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsWord# #-}
+readWord8OffAddrAsWord# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
+readWord8OffAddrAsWord# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsAddr# #-}
+readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)
+readWord8OffAddrAsAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsAddr# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsFloat# #-}
+readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)
+readWord8OffAddrAsFloat# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsFloat# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsDouble# #-}
+readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)
+readWord8OffAddrAsDouble# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsDouble# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsStablePtr# #-}
+readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)
+readWord8OffAddrAsStablePtr# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsStablePtr# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsInt16# #-}
+readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #)
+readWord8OffAddrAsInt16# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt16# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsWord16# #-}
+readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #)
+readWord8OffAddrAsWord16# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord16# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsInt32# #-}
+readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #)
+readWord8OffAddrAsInt32# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt32# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsWord32# #-}
+readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #)
+readWord8OffAddrAsWord32# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord32# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsInt64# #-}
+readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #)
+readWord8OffAddrAsInt64# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt64# a1 a2 a3
+{-# NOINLINE readWord8OffAddrAsWord64# #-}
+readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #)
+readWord8OffAddrAsWord64# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord64# a1 a2 a3
+{-# NOINLINE writeCharOffAddr# #-}
+writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeCharOffAddr# a1 a2 a3 a4 = GHC.Prim.writeCharOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWideCharOffAddr# #-}
+writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeWideCharOffAddr# a1 a2 a3 a4 = GHC.Prim.writeWideCharOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeIntOffAddr# #-}
+writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeIntOffAddr# a1 a2 a3 a4 = GHC.Prim.writeIntOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWordOffAddr# #-}
+writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWordOffAddr# a1 a2 a3 a4 = GHC.Prim.writeWordOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeAddrOffAddr# #-}
+writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
+writeAddrOffAddr# a1 a2 a3 a4 = GHC.Prim.writeAddrOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeFloatOffAddr# #-}
+writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
+writeFloatOffAddr# a1 a2 a3 a4 = GHC.Prim.writeFloatOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeDoubleOffAddr# #-}
+writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
+writeDoubleOffAddr# a1 a2 a3 a4 = GHC.Prim.writeDoubleOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeStablePtrOffAddr# #-}
+writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
+writeStablePtrOffAddr# a1 a2 a3 a4 = GHC.Prim.writeStablePtrOffAddr# a1 a2 a3 a4
+{-# NOINLINE writeInt8OffAddr# #-}
+writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# s -> State# s
+writeInt8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt8OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddr# #-}
+writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# s -> State# s
+writeWord8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeInt16OffAddr# #-}
+writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s
+writeInt16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt16OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord16OffAddr# #-}
+writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# s -> State# s
+writeWord16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord16OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeInt32OffAddr# #-}
+writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# s -> State# s
+writeInt32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt32OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord32OffAddr# #-}
+writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# s -> State# s
+writeWord32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord32OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeInt64OffAddr# #-}
+writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# s -> State# s
+writeInt64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt64OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord64OffAddr# #-}
+writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# s -> State# s
+writeWord64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord64OffAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsChar# #-}
+writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeWord8OffAddrAsChar# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsChar# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsWideChar# #-}
+writeWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# -> State# s -> State# s
+writeWord8OffAddrAsWideChar# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWideChar# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsInt# #-}
+writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# s -> State# s
+writeWord8OffAddrAsInt# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsWord# #-}
+writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# s -> State# s
+writeWord8OffAddrAsWord# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsAddr# #-}
+writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
+writeWord8OffAddrAsAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsAddr# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsFloat# #-}
+writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# s -> State# s
+writeWord8OffAddrAsFloat# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsFloat# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsDouble# #-}
+writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# s -> State# s
+writeWord8OffAddrAsDouble# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsDouble# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsStablePtr# #-}
+writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
+writeWord8OffAddrAsStablePtr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsStablePtr# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsInt16# #-}
+writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# s -> State# s
+writeWord8OffAddrAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt16# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsWord16# #-}
+writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# s -> State# s
+writeWord8OffAddrAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord16# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsInt32# #-}
+writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# s -> State# s
+writeWord8OffAddrAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt32# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsWord32# #-}
+writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# s -> State# s
+writeWord8OffAddrAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord32# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsInt64# #-}
+writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# s -> State# s
+writeWord8OffAddrAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt64# a1 a2 a3 a4
+{-# NOINLINE writeWord8OffAddrAsWord64# #-}
+writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# s -> State# s
+writeWord8OffAddrAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord64# a1 a2 a3 a4
+{-# NOINLINE atomicExchangeAddrAddr# #-}
+atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s,Addr# #)
+atomicExchangeAddrAddr# a1 a2 a3 = GHC.Prim.atomicExchangeAddrAddr# a1 a2 a3
+{-# NOINLINE atomicExchangeWordAddr# #-}
+atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+atomicExchangeWordAddr# a1 a2 a3 = GHC.Prim.atomicExchangeWordAddr# a1 a2 a3
+{-# NOINLINE atomicCasAddrAddr# #-}
+atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s,Addr# #)
+atomicCasAddrAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasAddrAddr# a1 a2 a3 a4
+{-# NOINLINE atomicCasWordAddr# #-}
+atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s,Word# #)
+atomicCasWordAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasWordAddr# a1 a2 a3 a4
+{-# NOINLINE atomicCasWord8Addr# #-}
+atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s,Word8# #)
+atomicCasWord8Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord8Addr# a1 a2 a3 a4
+{-# NOINLINE atomicCasWord16Addr# #-}
+atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s,Word16# #)
+atomicCasWord16Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord16Addr# a1 a2 a3 a4
+{-# NOINLINE atomicCasWord32Addr# #-}
+atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s,Word32# #)
+atomicCasWord32Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord32Addr# a1 a2 a3 a4
+{-# NOINLINE atomicCasWord64Addr# #-}
+atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# s -> (# State# s,Word64# #)
+atomicCasWord64Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord64Addr# a1 a2 a3 a4
+{-# NOINLINE fetchAddWordAddr# #-}
+fetchAddWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchAddWordAddr# a1 a2 a3 = GHC.Prim.fetchAddWordAddr# a1 a2 a3
+{-# NOINLINE fetchSubWordAddr# #-}
+fetchSubWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchSubWordAddr# a1 a2 a3 = GHC.Prim.fetchSubWordAddr# a1 a2 a3
+{-# NOINLINE fetchAndWordAddr# #-}
+fetchAndWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchAndWordAddr# a1 a2 a3 = GHC.Prim.fetchAndWordAddr# a1 a2 a3
+{-# NOINLINE fetchNandWordAddr# #-}
+fetchNandWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchNandWordAddr# a1 a2 a3 = GHC.Prim.fetchNandWordAddr# a1 a2 a3
+{-# NOINLINE fetchOrWordAddr# #-}
+fetchOrWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchOrWordAddr# a1 a2 a3 = GHC.Prim.fetchOrWordAddr# a1 a2 a3
+{-# NOINLINE fetchXorWordAddr# #-}
+fetchXorWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
+fetchXorWordAddr# a1 a2 a3 = GHC.Prim.fetchXorWordAddr# a1 a2 a3
+{-# NOINLINE atomicReadWordAddr# #-}
+atomicReadWordAddr# :: Addr# -> State# s -> (# State# s,Word# #)
+atomicReadWordAddr# a1 a2 = GHC.Prim.atomicReadWordAddr# a1 a2
+{-# NOINLINE atomicWriteWordAddr# #-}
+atomicWriteWordAddr# :: Addr# -> Word# -> State# s -> State# s
+atomicWriteWordAddr# a1 a2 a3 = GHC.Prim.atomicWriteWordAddr# a1 a2 a3
+{-# NOINLINE newMutVar# #-}
+newMutVar# :: a_levpoly -> State# s -> (# State# s,MutVar# s a_levpoly #)
+newMutVar# a1 a2 = GHC.Prim.newMutVar# a1 a2
+{-# NOINLINE readMutVar# #-}
+readMutVar# :: MutVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+readMutVar# a1 a2 = GHC.Prim.readMutVar# a1 a2
+{-# NOINLINE writeMutVar# #-}
+writeMutVar# :: MutVar# s a_levpoly -> a_levpoly -> State# s -> State# s
+writeMutVar# a1 a2 a3 = GHC.Prim.writeMutVar# a1 a2 a3
+{-# NOINLINE atomicSwapMutVar# #-}
+atomicSwapMutVar# :: MutVar# s a_levpoly -> a_levpoly -> State# s -> (# State# s,a_levpoly #)
+atomicSwapMutVar# a1 a2 a3 = GHC.Prim.atomicSwapMutVar# a1 a2 a3
+{-# NOINLINE atomicModifyMutVar2# #-}
+atomicModifyMutVar2# :: MutVar# s a -> (a -> c) -> State# s -> (# State# s,a,c #)
+atomicModifyMutVar2# a1 a2 a3 = GHC.Prim.atomicModifyMutVar2# a1 a2 a3
+{-# NOINLINE atomicModifyMutVar_# #-}
+atomicModifyMutVar_# :: MutVar# s a -> (a -> a) -> State# s -> (# State# s,a,a #)
+atomicModifyMutVar_# a1 a2 a3 = GHC.Prim.atomicModifyMutVar_# a1 a2 a3
+{-# NOINLINE casMutVar# #-}
+casMutVar# :: MutVar# s a_levpoly -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #)
+casMutVar# a1 a2 a3 a4 = GHC.Prim.casMutVar# a1 a2 a3 a4
+{-# NOINLINE catch# #-}
+catch# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> (b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)
+catch# a1 a2 a3 = GHC.Prim.catch# a1 a2 a3
+{-# NOINLINE raise# #-}
+raise# :: a_levpoly -> b_reppoly
+raise# a1 = GHC.Prim.raise# a1
+{-# NOINLINE raiseUnderflow# #-}
+raiseUnderflow# :: (# #) -> b_reppoly
+raiseUnderflow# a1 = GHC.Prim.raiseUnderflow# a1
+{-# NOINLINE raiseOverflow# #-}
+raiseOverflow# :: (# #) -> b_reppoly
+raiseOverflow# a1 = GHC.Prim.raiseOverflow# a1
+{-# NOINLINE raiseDivZero# #-}
+raiseDivZero# :: (# #) -> b_reppoly
+raiseDivZero# a1 = GHC.Prim.raiseDivZero# a1
+{-# NOINLINE raiseIO# #-}
+raiseIO# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),b_reppoly #)
+raiseIO# a1 a2 = GHC.Prim.raiseIO# a1 a2
+{-# NOINLINE maskAsyncExceptions# #-}
+maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)
+maskAsyncExceptions# a1 a2 = GHC.Prim.maskAsyncExceptions# a1 a2
+{-# NOINLINE maskUninterruptible# #-}
+maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)
+maskUninterruptible# a1 a2 = GHC.Prim.maskUninterruptible# a1 a2
+{-# NOINLINE unmaskAsyncExceptions# #-}
+unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)
+unmaskAsyncExceptions# a1 a2 = GHC.Prim.unmaskAsyncExceptions# a1 a2
+{-# NOINLINE getMaskingState# #-}
+getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
+getMaskingState# a1 = GHC.Prim.getMaskingState# a1
+{-# NOINLINE newPromptTag# #-}
+newPromptTag# :: State# (RealWorld) -> (# State# (RealWorld),PromptTag# a #)
+newPromptTag# a1 = GHC.Prim.newPromptTag# a1
+{-# NOINLINE prompt# #-}
+prompt# :: PromptTag# a -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
+prompt# a1 a2 a3 = GHC.Prim.prompt# a1 a2 a3
+{-# NOINLINE control0# #-}
+control0# :: PromptTag# a -> (((State# (RealWorld) -> (# State# (RealWorld),b_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),b_reppoly #)
+control0# a1 a2 a3 = GHC.Prim.control0# a1 a2 a3
+{-# NOINLINE atomically# #-}
+atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)
+atomically# a1 a2 = GHC.Prim.atomically# a1 a2
+{-# NOINLINE retry# #-}
+retry# :: State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)
+retry# a1 = GHC.Prim.retry# a1
+{-# NOINLINE catchRetry# #-}
+catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)
+catchRetry# a1 a2 a3 = GHC.Prim.catchRetry# a1 a2 a3
+{-# NOINLINE catchSTM# #-}
+catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)
+catchSTM# a1 a2 a3 = GHC.Prim.catchSTM# a1 a2 a3
+{-# NOINLINE newTVar# #-}
+newTVar# :: a_levpoly -> State# s -> (# State# s,TVar# s a_levpoly #)
+newTVar# a1 a2 = GHC.Prim.newTVar# a1 a2
+{-# NOINLINE readTVar# #-}
+readTVar# :: TVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+readTVar# a1 a2 = GHC.Prim.readTVar# a1 a2
+{-# NOINLINE readTVarIO# #-}
+readTVarIO# :: TVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+readTVarIO# a1 a2 = GHC.Prim.readTVarIO# a1 a2
+{-# NOINLINE writeTVar# #-}
+writeTVar# :: TVar# s a_levpoly -> a_levpoly -> State# s -> State# s
+writeTVar# a1 a2 a3 = GHC.Prim.writeTVar# a1 a2 a3
+{-# NOINLINE newMVar# #-}
+newMVar# :: State# s -> (# State# s,MVar# s a_levpoly #)
+newMVar# a1 = GHC.Prim.newMVar# a1
+{-# NOINLINE takeMVar# #-}
+takeMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+takeMVar# a1 a2 = GHC.Prim.takeMVar# a1 a2
+{-# NOINLINE tryTakeMVar# #-}
+tryTakeMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #)
+tryTakeMVar# a1 a2 = GHC.Prim.tryTakeMVar# a1 a2
+{-# NOINLINE putMVar# #-}
+putMVar# :: MVar# s a_levpoly -> a_levpoly -> State# s -> State# s
+putMVar# a1 a2 a3 = GHC.Prim.putMVar# a1 a2 a3
+{-# NOINLINE tryPutMVar# #-}
+tryPutMVar# :: MVar# s a_levpoly -> a_levpoly -> State# s -> (# State# s,Int# #)
+tryPutMVar# a1 a2 a3 = GHC.Prim.tryPutMVar# a1 a2 a3
+{-# NOINLINE readMVar# #-}
+readMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+readMVar# a1 a2 = GHC.Prim.readMVar# a1 a2
+{-# NOINLINE tryReadMVar# #-}
+tryReadMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #)
+tryReadMVar# a1 a2 = GHC.Prim.tryReadMVar# a1 a2
+{-# NOINLINE isEmptyMVar# #-}
+isEmptyMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int# #)
+isEmptyMVar# a1 a2 = GHC.Prim.isEmptyMVar# a1 a2
+{-# NOINLINE newIOPort# #-}
+newIOPort# :: State# s -> (# State# s,IOPort# s a_levpoly #)
+newIOPort# a1 = GHC.Prim.newIOPort# a1
+{-# NOINLINE readIOPort# #-}
+readIOPort# :: IOPort# s a_levpoly -> State# s -> (# State# s,a_levpoly #)
+readIOPort# a1 a2 = GHC.Prim.readIOPort# a1 a2
+{-# NOINLINE writeIOPort# #-}
+writeIOPort# :: IOPort# s a_levpoly -> a_levpoly -> State# s -> (# State# s,Int# #)
+writeIOPort# a1 a2 a3 = GHC.Prim.writeIOPort# a1 a2 a3
+{-# NOINLINE delay# #-}
+delay# :: Int# -> State# s -> State# s
+delay# a1 a2 = GHC.Prim.delay# a1 a2
+{-# NOINLINE waitRead# #-}
+waitRead# :: Int# -> State# s -> State# s
+waitRead# a1 a2 = GHC.Prim.waitRead# a1 a2
+{-# NOINLINE waitWrite# #-}
+waitWrite# :: Int# -> State# s -> State# s
+waitWrite# a1 a2 = GHC.Prim.waitWrite# a1 a2
+{-# NOINLINE fork# #-}
+fork# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
+fork# a1 a2 = GHC.Prim.fork# a1 a2
+{-# NOINLINE forkOn# #-}
+forkOn# :: Int# -> (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
+forkOn# a1 a2 a3 = GHC.Prim.forkOn# a1 a2 a3
+{-# NOINLINE killThread# #-}
+killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
+killThread# a1 a2 a3 = GHC.Prim.killThread# a1 a2 a3
+{-# NOINLINE yield# #-}
+yield# :: State# (RealWorld) -> State# (RealWorld)
+yield# a1 = GHC.Prim.yield# a1
+{-# NOINLINE myThreadId# #-}
+myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
+myThreadId# a1 = GHC.Prim.myThreadId# a1
+{-# NOINLINE labelThread# #-}
+labelThread# :: ThreadId# -> ByteArray# -> State# (RealWorld) -> State# (RealWorld)
+labelThread# a1 a2 a3 = GHC.Prim.labelThread# a1 a2 a3
+{-# NOINLINE isCurrentThreadBound# #-}
+isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
+isCurrentThreadBound# a1 = GHC.Prim.isCurrentThreadBound# a1
+{-# NOINLINE noDuplicate# #-}
+noDuplicate# :: State# s -> State# s
+noDuplicate# a1 = GHC.Prim.noDuplicate# a1
+{-# NOINLINE threadLabel# #-}
+threadLabel# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,ByteArray# #)
+threadLabel# a1 a2 = GHC.Prim.threadLabel# a1 a2
+{-# NOINLINE threadStatus# #-}
+threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
+threadStatus# a1 a2 = GHC.Prim.threadStatus# a1 a2
+{-# NOINLINE listThreads# #-}
+listThreads# :: State# (RealWorld) -> (# State# (RealWorld),Array# (ThreadId#) #)
+listThreads# a1 = GHC.Prim.listThreads# a1
+{-# NOINLINE mkWeak# #-}
+mkWeak# :: a_levpoly -> b_levpoly -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b_levpoly #)
+mkWeak# a1 a2 a3 a4 = GHC.Prim.mkWeak# a1 a2 a3 a4
+{-# NOINLINE mkWeakNoFinalizer# #-}
+mkWeakNoFinalizer# :: a_levpoly -> b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Weak# b_levpoly #)
+mkWeakNoFinalizer# a1 a2 a3 = GHC.Prim.mkWeakNoFinalizer# a1 a2 a3
+{-# NOINLINE addCFinalizerToWeak# #-}
+addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
+addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = GHC.Prim.addCFinalizerToWeak# a1 a2 a3 a4 a5 a6
+{-# NOINLINE deRefWeak# #-}
+deRefWeak# :: Weak# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int#,a_levpoly #)
+deRefWeak# a1 a2 = GHC.Prim.deRefWeak# a1 a2
+{-# NOINLINE finalizeWeak# #-}
+finalizeWeak# :: Weak# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #)
+finalizeWeak# a1 a2 = GHC.Prim.finalizeWeak# a1 a2
+{-# NOINLINE touch# #-}
+touch# :: a_levpoly -> State# s -> State# s
+touch# a1 a2 = GHC.Prim.touch# a1 a2
+{-# NOINLINE makeStablePtr# #-}
+makeStablePtr# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a_levpoly #)
+makeStablePtr# a1 a2 = GHC.Prim.makeStablePtr# a1 a2
+{-# NOINLINE deRefStablePtr# #-}
+deRefStablePtr# :: StablePtr# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)
+deRefStablePtr# a1 a2 = GHC.Prim.deRefStablePtr# a1 a2
+{-# NOINLINE eqStablePtr# #-}
+eqStablePtr# :: StablePtr# a_levpoly -> StablePtr# a_levpoly -> Int#
+eqStablePtr# a1 a2 = GHC.Prim.eqStablePtr# a1 a2
+{-# NOINLINE makeStableName# #-}
+makeStableName# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),StableName# a_levpoly #)
+makeStableName# a1 a2 = GHC.Prim.makeStableName# a1 a2
+{-# NOINLINE stableNameToInt# #-}
+stableNameToInt# :: StableName# a_levpoly -> Int#
+stableNameToInt# a1 = GHC.Prim.stableNameToInt# a1
+{-# NOINLINE compactNew# #-}
+compactNew# :: Word# -> State# (RealWorld) -> (# State# (RealWorld),Compact# #)
+compactNew# a1 a2 = GHC.Prim.compactNew# a1 a2
+{-# NOINLINE compactResize# #-}
+compactResize# :: Compact# -> Word# -> State# (RealWorld) -> State# (RealWorld)
+compactResize# a1 a2 a3 = GHC.Prim.compactResize# a1 a2 a3
+{-# NOINLINE compactContains# #-}
+compactContains# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
+compactContains# a1 a2 a3 = GHC.Prim.compactContains# a1 a2 a3
+{-# NOINLINE compactContainsAny# #-}
+compactContainsAny# :: a -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
+compactContainsAny# a1 a2 = GHC.Prim.compactContainsAny# a1 a2
+{-# NOINLINE compactGetFirstBlock# #-}
+compactGetFirstBlock# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #)
+compactGetFirstBlock# a1 a2 = GHC.Prim.compactGetFirstBlock# a1 a2
+{-# NOINLINE compactGetNextBlock# #-}
+compactGetNextBlock# :: Compact# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #)
+compactGetNextBlock# a1 a2 a3 = GHC.Prim.compactGetNextBlock# a1 a2 a3
+{-# NOINLINE compactAllocateBlock# #-}
+compactAllocateBlock# :: Word# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
+compactAllocateBlock# a1 a2 a3 = GHC.Prim.compactAllocateBlock# a1 a2 a3
+{-# NOINLINE compactFixupPointers# #-}
+compactFixupPointers# :: Addr# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Compact#,Addr# #)
+compactFixupPointers# a1 a2 a3 = GHC.Prim.compactFixupPointers# a1 a2 a3
+{-# NOINLINE compactAdd# #-}
+compactAdd# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #)
+compactAdd# a1 a2 a3 = GHC.Prim.compactAdd# a1 a2 a3
+{-# NOINLINE compactAddWithSharing# #-}
+compactAddWithSharing# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #)
+compactAddWithSharing# a1 a2 a3 = GHC.Prim.compactAddWithSharing# a1 a2 a3
+{-# NOINLINE compactSize# #-}
+compactSize# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Word# #)
+compactSize# a1 a2 = GHC.Prim.compactSize# a1 a2
+{-# NOINLINE reallyUnsafePtrEquality# #-}
+reallyUnsafePtrEquality# :: a_levpoly -> b_levpoly -> Int#
+reallyUnsafePtrEquality# a1 a2 = GHC.Prim.reallyUnsafePtrEquality# a1 a2
+{-# NOINLINE par# #-}
+par# :: a -> Int#
+par# a1 = GHC.Prim.par# a1
+{-# NOINLINE spark# #-}
+spark# :: a -> State# s -> (# State# s,a #)
+spark# a1 a2 = GHC.Prim.spark# a1 a2
+{-# NOINLINE getSpark# #-}
+getSpark# :: State# s -> (# State# s,Int#,a #)
+getSpark# a1 = GHC.Prim.getSpark# a1
+{-# NOINLINE numSparks# #-}
+numSparks# :: State# s -> (# State# s,Int# #)
+numSparks# a1 = GHC.Prim.numSparks# a1
+{-# NOINLINE keepAlive# #-}
+keepAlive# :: a_levpoly -> State# s -> (State# s -> b_reppoly) -> b_reppoly
+keepAlive# a1 a2 a3 = GHC.Prim.keepAlive# a1 a2 a3
+{-# NOINLINE dataToTagSmall# #-}
+dataToTagSmall# :: a_levpoly -> Int#
+dataToTagSmall# a1 = GHC.Prim.dataToTagSmall# a1
+{-# NOINLINE dataToTagLarge# #-}
+dataToTagLarge# :: a_levpoly -> Int#
+dataToTagLarge# a1 = GHC.Prim.dataToTagLarge# a1
+{-# NOINLINE addrToAny# #-}
+addrToAny# :: Addr# -> (# a_levpoly #)
+addrToAny# a1 = GHC.Prim.addrToAny# a1
+{-# NOINLINE anyToAddr# #-}
+anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
+anyToAddr# a1 a2 = GHC.Prim.anyToAddr# a1 a2
+{-# NOINLINE mkApUpd0# #-}
+mkApUpd0# :: BCO -> (# a #)
+mkApUpd0# a1 = GHC.Prim.mkApUpd0# a1
+{-# NOINLINE newBCO# #-}
+newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO #)
+newBCO# a1 a2 a3 a4 a5 a6 = GHC.Prim.newBCO# a1 a2 a3 a4 a5 a6
+{-# NOINLINE unpackClosure# #-}
+unpackClosure# :: a -> (# Addr#,ByteArray#,Array# b #)
+unpackClosure# a1 = GHC.Prim.unpackClosure# a1
+{-# NOINLINE closureSize# #-}
+closureSize# :: a -> Int#
+closureSize# a1 = GHC.Prim.closureSize# a1
+{-# NOINLINE getApStackVal# #-}
+getApStackVal# :: a -> Int# -> (# Int#,b #)
+getApStackVal# a1 a2 = GHC.Prim.getApStackVal# a1 a2
+{-# NOINLINE getCCSOf# #-}
+getCCSOf# :: a -> State# s -> (# State# s,Addr# #)
+getCCSOf# a1 a2 = GHC.Prim.getCCSOf# a1 a2
+{-# NOINLINE getCurrentCCS# #-}
+getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)
+getCurrentCCS# a1 a2 = GHC.Prim.getCurrentCCS# a1 a2
+{-# NOINLINE clearCCS# #-}
+clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #)
+clearCCS# a1 a2 = GHC.Prim.clearCCS# a1 a2
+{-# NOINLINE whereFrom# #-}
+whereFrom# :: a -> Addr# -> State# s -> (# State# s,Int# #)
+whereFrom# a1 a2 a3 = GHC.Prim.whereFrom# a1 a2 a3
+{-# NOINLINE traceEvent# #-}
+traceEvent# :: Addr# -> State# s -> State# s
+traceEvent# a1 a2 = GHC.Prim.traceEvent# a1 a2
+{-# NOINLINE traceBinaryEvent# #-}
+traceBinaryEvent# :: Addr# -> Int# -> State# s -> State# s
+traceBinaryEvent# a1 a2 a3 = GHC.Prim.traceBinaryEvent# a1 a2 a3
+{-# NOINLINE traceMarker# #-}
+traceMarker# :: Addr# -> State# s -> State# s
+traceMarker# a1 a2 = GHC.Prim.traceMarker# a1 a2
+{-# NOINLINE setThreadAllocationCounter# #-}
+setThreadAllocationCounter# :: Int64# -> State# (RealWorld) -> State# (RealWorld)
+setThreadAllocationCounter# a1 a2 = GHC.Prim.setThreadAllocationCounter# a1 a2
+{-# NOINLINE prefetchByteArray3# #-}
+prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s
+prefetchByteArray3# a1 a2 a3 = GHC.Prim.prefetchByteArray3# a1 a2 a3
+{-# NOINLINE prefetchMutableByteArray3# #-}
+prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s
+prefetchMutableByteArray3# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray3# a1 a2 a3
+{-# NOINLINE prefetchAddr3# #-}
+prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s
+prefetchAddr3# a1 a2 a3 = GHC.Prim.prefetchAddr3# a1 a2 a3
+{-# NOINLINE prefetchValue3# #-}
+prefetchValue3# :: a -> State# s -> State# s
+prefetchValue3# a1 a2 = GHC.Prim.prefetchValue3# a1 a2
+{-# NOINLINE prefetchByteArray2# #-}
+prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s
+prefetchByteArray2# a1 a2 a3 = GHC.Prim.prefetchByteArray2# a1 a2 a3
+{-# NOINLINE prefetchMutableByteArray2# #-}
+prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s
+prefetchMutableByteArray2# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray2# a1 a2 a3
+{-# NOINLINE prefetchAddr2# #-}
+prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s
+prefetchAddr2# a1 a2 a3 = GHC.Prim.prefetchAddr2# a1 a2 a3
+{-# NOINLINE prefetchValue2# #-}
+prefetchValue2# :: a -> State# s -> State# s
+prefetchValue2# a1 a2 = GHC.Prim.prefetchValue2# a1 a2
+{-# NOINLINE prefetchByteArray1# #-}
+prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s
+prefetchByteArray1# a1 a2 a3 = GHC.Prim.prefetchByteArray1# a1 a2 a3
+{-# NOINLINE prefetchMutableByteArray1# #-}
+prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s
+prefetchMutableByteArray1# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray1# a1 a2 a3
+{-# NOINLINE prefetchAddr1# #-}
+prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s
+prefetchAddr1# a1 a2 a3 = GHC.Prim.prefetchAddr1# a1 a2 a3
+{-# NOINLINE prefetchValue1# #-}
+prefetchValue1# :: a -> State# s -> State# s
+prefetchValue1# a1 a2 = GHC.Prim.prefetchValue1# a1 a2
+{-# NOINLINE prefetchByteArray0# #-}
+prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s
+prefetchByteArray0# a1 a2 a3 = GHC.Prim.prefetchByteArray0# a1 a2 a3
+{-# NOINLINE prefetchMutableByteArray0# #-}
+prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s
+prefetchMutableByteArray0# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray0# a1 a2 a3
+{-# NOINLINE prefetchAddr0# #-}
+prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s
+prefetchAddr0# a1 a2 a3 = GHC.Prim.prefetchAddr0# a1 a2 a3
+{-# NOINLINE prefetchValue0# #-}
+prefetchValue0# :: a -> State# s -> State# s
+prefetchValue0# a1 a2 = GHC.Prim.prefetchValue0# a1 a2
diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs
--- a/GHC/Tuple.hs
+++ b/GHC/Tuple.hs
@@ -1,211 +1,600 @@
{-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE NoImplicitPrelude, DeriveGeneric #-}
+{-# LANGUAGE NoImplicitPrelude, PatternSynonyms, ExplicitNamespaces #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Tuple
-- Copyright : (c) The University of Glasgow 2001
-- License : BSD-style (see the file libraries/ghc-prim/LICENSE)
---
+--
-- Maintainer : libraries@haskell.org
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
--
-- The tuple data types
--
+-- Users should not import this module. It is GHC internal only.
+--
-----------------------------------------------------------------------------
-module GHC.Tuple where
+module GHC.Tuple (
+ Tuple0, Tuple1,
+ Unit(..),
+ Solo (Solo, MkSolo), getSolo,
+ Tuple2(..), Tuple3(..), Tuple4(..), Tuple5(..), Tuple6(..), Tuple7(..), Tuple8(..), Tuple9(..),
+ Tuple10(..), Tuple11(..), Tuple12(..), Tuple13(..), Tuple14(..), Tuple15(..), Tuple16(..), Tuple17(..), Tuple18(..), Tuple19(..),
+ Tuple20(..), Tuple21(..), Tuple22(..), Tuple23(..), Tuple24(..), Tuple25(..), Tuple26(..), Tuple27(..), Tuple28(..), Tuple29(..),
+ Tuple30(..), Tuple31(..), Tuple32(..), Tuple33(..), Tuple34(..), Tuple35(..), Tuple36(..), Tuple37(..), Tuple38(..), Tuple39(..),
+ Tuple40(..), Tuple41(..), Tuple42(..), Tuple43(..), Tuple44(..), Tuple45(..), Tuple46(..), Tuple47(..), Tuple48(..), Tuple49(..),
+ Tuple50(..), Tuple51(..), Tuple52(..), Tuple53(..), Tuple54(..), Tuple55(..), Tuple56(..), Tuple57(..), Tuple58(..), Tuple59(..),
+ Tuple60(..), Tuple61(..), Tuple62(..), Tuple63(..), Tuple64(..),
+) where
+-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base
+import GHC.Types ()
default () -- Double and Integer aren't available yet
--- | The unit datatype @()@ has one non-undefined member, the nullary
+-- | The unit datatype @Unit@ has one non-undefined member, the nullary
-- constructor @()@.
-data () = ()
+--
+-- @since 0.11.0
+--
+data Unit = ()
-data (,) a b = (,) a b
-data (,,) a b c = (,,) a b c
-data (,,,) a b c d = (,,,) a b c d
-data (,,,,) a b c d e = (,,,,) a b c d e
-data (,,,,,) a b c d e f = (,,,,,) a b c d e f
-data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g
-data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h
-data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i
-data (,,,,,,,,,) a b c d e f g h i j = (,,,,,,,,,) a b c d e f g h i j
-data (,,,,,,,,,,) a b c d e f g h i j k = (,,,,,,,,,,) a b c d e f g h i j k
-data (,,,,,,,,,,,) a b c d e f g h i j k l = (,,,,,,,,,,,) a b c d e f g h i j k l
-data (,,,,,,,,,,,,) a b c d e f g h i j k l m = (,,,,,,,,,,,,) a b c d e f g h i j k l m
-data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n = (,,,,,,,,,,,,,) a b c d e f g h i j k l m n
-data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o = (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o
-data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p = (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p
-data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
- = (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
-data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
- = (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
-data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
- = (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
-data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
- = (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
-data (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
- = (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
-data (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
- = (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
-data (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
- = (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
-data (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
- = (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
-data (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
- = (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
-data (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
- = (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
+-- The desugarer uses 1-tuples,
+-- but "Unit" is already used up for 0-tuples
+-- See Note [One-tuples] in GHC.Builtin.Types
-{- Manuel says: Including one more declaration gives a segmentation fault.
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___
-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ v___
- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ v___
--}
+-- | @Solo@ is the canonical lifted 1-tuple, just like 'Tuple2' is the canonical
+-- lifted 2-tuple (pair) and 'Tuple3' is the canonical lifted 3-tuple (triple).
+--
+-- The most important feature of @Solo@ is that it is possible to force its
+-- "outside" (usually by pattern matching) without forcing its "inside",
+-- because it is defined as a datatype rather than a newtype. One situation
+-- where this can be useful is when writing a function to extract a value from
+-- a data structure. Suppose you write an implementation of arrays and offer
+-- only this function to index into them:
+--
+-- @
+-- index :: Array a -> Int -> a
+-- @
+--
+-- Now imagine that someone wants to extract a value from an array and store it
+-- in a lazy-valued finite map/dictionary:
+--
+-- @
+-- insert "hello" (arr `index` 12) m
+-- @
+--
+-- This can actually lead to a space leak. The value is not actually extracted
+-- from the array until that value (now buried in a map) is forced. That means
+-- the entire array may be kept live by just that value! Often, the solution
+-- is to use a strict map, or to force the value before storing it, but for
+-- some purposes that's undesirable.
+--
+-- One common solution is to include an indexing function that can produce its
+-- result in an arbitrary @Applicative@ context:
+--
+-- @
+-- indexA :: Applicative f => Array a -> Int -> f a
+-- @
+--
+-- When using @indexA@ in a /pure/ context, @Solo@ serves as a handy
+-- @Applicative@ functor to hold the result. You could write a non-leaky
+-- version of the above example thus:
+--
+-- @
+-- case arr `indexA` 12 of
+-- Solo a -> insert "hello" a m
+-- @
+--
+-- While such simple extraction functions are the most common uses for
+-- unary tuples, they can also be useful for fine-grained control of
+-- strict-spined data structure traversals, and for unifying the
+-- implementations of lazy and strict mapping functions.
+data Solo a = MkSolo a
+
+-- This will have to wait for https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0065-type-infix.rst
+-- Otherwise the deprecation would apply to the data type as well.
+{-# DEPRECATED data Solo "The Solo constructor has been renamed to MkSolo to avoid punning." #-}
+pattern Solo :: a -> Solo a
+pattern Solo x = MkSolo x
+{-# COMPLETE Solo #-}
+
+-- | Extract the value from a 'Solo'. Very often, values should be extracted
+-- directly using pattern matching, to control just what gets evaluated when.
+-- @getSolo@ is for convenience in situations where that is not the case:
+--
+-- When the result is passed to a /strict/ function, it makes no difference
+-- whether the pattern matching is done on the \"outside\" or on the
+-- \"inside\":
+--
+-- @
+-- Data.Set.insert (getSolo sol) set === case sol of Solo v -> Data.Set.insert v set
+-- @
+--
+-- A traversal may be performed in 'Solo' in order to control evaluation
+-- internally, while using @getSolo@ to extract the final result. A strict
+-- mapping function, for example, could be defined
+--
+-- @
+-- map' :: Traversable t => (a -> b) -> t a -> t b
+-- map' f = getSolo . traverse ((Solo $!) . f)
+-- @
+getSolo :: Solo a -> a
+-- getSolo is a standalone function, rather than a record field of Solo,
+-- because Solo is a wired-in TyCon, and a wired-in TyCon that has
+-- record fields is a bit more inconvenient than if it doesn't.
+-- (No other wired-in TyCon has record fields.) So it seems easier
+-- to have getSolo as its own separate function (#20562)
+getSolo (MkSolo a) = a
+
+-- | A tuple of zero elements, a synonym for 'Unit'.
+--
+-- @since 0.11.0
+--
+type Tuple0 = Unit
+
+-- | A tuple of one element, a synonym for 'Solo'.
+--
+-- @since 0.11.0
+--
+type Tuple1 = Solo
+
+-- | A tuple of two elements.
+--
+-- @since 0.11.0
+--
+data Tuple2 a b = (a,b)
+
+-- | A tuple of three elements.
+--
+-- @since 0.11.0
+--
+data Tuple3 a b c = (a,b,c)
+
+-- | A tuple of four elements.
+--
+-- @since 0.11.0
+--
+data Tuple4 a b c d = (a,b,c,d)
+
+-- | A tuple of five elements.
+--
+-- @since 0.11.0
+--
+data Tuple5 a b c d e = (a,b,c,d,e)
+
+-- | A tuple of six elements.
+--
+-- @since 0.11.0
+--
+data Tuple6 a b c d e f = (a,b,c,d,e,f)
+
+-- | A tuple of seven elements.
+--
+-- @since 0.11.0
+--
+data Tuple7 a b c d e f g = (a,b,c,d,e,f,g)
+
+-- | A tuple of eight elements.
+--
+-- @since 0.11.0
+--
+data Tuple8 a b c d e f g h = (a,b,c,d,e,f,g,h)
+
+-- | A tuple of nine elements.
+--
+-- @since 0.11.0
+--
+data Tuple9 a b c d e f g h i = (a,b,c,d,e,f,g,h,i)
+
+-- | A tuple of ten elements.
+--
+-- @since 0.11.0
+--
+data Tuple10 a b c d e f g h i j = (a,b,c,d,e,f,g,h,i,j)
+
+-- | A tuple of eleven elements.
+--
+-- @since 0.11.0
+--
+data Tuple11 a b c d e f g h i j k = (a,b,c,d,e,f,g,h,i,j,k)
+
+-- | A tuple of twelve elements.
+--
+-- @since 0.11.0
+--
+data Tuple12 a b c d e f g h i j k l = (a,b,c,d,e,f,g,h,i,j,k,l)
+
+-- | A tuple of 13 elements.
+--
+-- @since 0.11.0
+--
+data Tuple13 a b c d e f g h i j k l m = (a,b,c,d,e,f,g,h,i,j,k,l,m)
+
+-- | A tuple of 14 elements.
+--
+-- @since 0.11.0
+--
+data Tuple14 a b c d e f g h i j k l m n = (a,b,c,d,e,f,g,h,i,j,k,l,m,n)
+
+-- | A tuple of 15 elements.
+--
+-- @since 0.11.0
+--
+data Tuple15 a b c d e f g h i j k l m n o = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
+
+-- | A tuple of 16 elements.
+--
+-- @since 0.11.0
+--
+data Tuple16 a b c d e f g h i j k l m n o p = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
+
+-- | A tuple of 17 elements.
+--
+-- @since 0.11.0
+--
+data Tuple17 a b c d e f g h i j k l m n o p q = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)
+
+-- | A tuple of 18 elements.
+--
+-- @since 0.11.0
+--
+data Tuple18 a b c d e f g h i j k l m n o p q r = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)
+
+-- | A tuple of 19 elements.
+--
+-- @since 0.11.0
+--
+data Tuple19 a b c d e f g h i j k l m n o p q r s = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)
+
+-- | A tuple of 20 elements.
+--
+-- @since 0.11.0
+--
+data Tuple20 a b c d e f g h i j k l m n o p q r s t = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)
+
+-- | A tuple of 21 elements.
+
+--
+-- @since 0.11.0
+--
+data Tuple21 a b c d e f g h i j k l m n o p q r s t u = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u)
+
+-- | A tuple of 22 elements.
+--
+-- @since 0.11.0
+--
+data Tuple22 a b c d e f g h i j k l m n o p q r s t u v = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v)
+
+-- | A tuple of 23 elements.
+--
+-- @since 0.11.0
+--
+data Tuple23 a b c d e f g h i j k l m n o p q r s t u v w = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w)
+
+-- | A tuple of 24 elements.
+--
+-- @since 0.11.0
+--
+data Tuple24 a b c d e f g h i j k l m n o p q r s t u v w x = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x)
+
+-- | A tuple of 25 elements.
+--
+-- @since 0.11.0
+--
+data Tuple25 a b c d e f g h i j k l m n o p q r s t u v w x y = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y)
+
+-- | A tuple of 26 elements.
+--
+-- @since 0.11.0
+--
+data Tuple26 a b c d e f g h i j k l m n o p q r s t u v w x y z = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z)
+
+-- | A tuple of 27 elements.
+--
+-- @since 0.11.0
+--
+data Tuple27 a b c d e f g h i j k l m n o p q r s t u v w x y z a1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1)
+
+-- | A tuple of 28 elements.
+--
+-- @since 0.11.0
+--
+data Tuple28 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1)
+
+-- | A tuple of 29 elements.
+--
+-- @since 0.11.0
+--
+data Tuple29 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1)
+
+-- | A tuple of 30 elements.
+--
+-- @since 0.11.0
+--
+data Tuple30 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1)
+
+-- | A tuple of 31 elements.
+--
+-- @since 0.11.0
+--
+data Tuple31 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1)
+
+-- | A tuple of 32 elements.
+--
+-- @since 0.11.0
+--
+data Tuple32 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1)
+
+-- | A tuple of 33 elements.
+--
+-- @since 0.11.0
+--
+data Tuple33 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1)
+
+-- | A tuple of 34 elements.
+--
+-- @since 0.11.0
+--
+data Tuple34 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1)
+
+-- | A tuple of 35 elements.
+--
+-- @since 0.11.0
+--
+data Tuple35 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1)
+
+-- | A tuple of 36 elements.
+--
+-- @since 0.11.0
+--
+data Tuple36 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1)
+
+-- | A tuple of 37 elements.
+--
+-- @since 0.11.0
+--
+data Tuple37 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1)
+
+-- | A tuple of 38 elements.
+--
+-- @since 0.11.0
+--
+data Tuple38 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1)
+
+-- | A tuple of 39 elements.
+--
+-- @since 0.11.0
+--
+data Tuple39 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1)
+
+-- | A tuple of 40 elements.
+--
+-- @since 0.11.0
+--
+data Tuple40 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1)
+
+-- | A tuple of 41 elements.
+--
+-- @since 0.11.0
+--
+data Tuple41 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1)
+
+-- | A tuple of 42 elements.
+--
+-- @since 0.11.0
+--
+data Tuple42 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1)
+
+-- | A tuple of 43 elements.
+--
+-- @since 0.11.0
+--
+data Tuple43 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1)
+
+-- | A tuple of 44 elements.
+--
+-- @since 0.11.0
+--
+data Tuple44 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1)
+
+-- | A tuple of 45 elements.
+--
+-- @since 0.11.0
+--
+data Tuple45 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1)
+
+-- | A tuple of 46 elements.
+--
+-- @since 0.11.0
+--
+data Tuple46 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1)
+
+-- | A tuple of 47 elements.
+--
+-- @since 0.11.0
+--
+data Tuple47 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1)
+
+-- | A tuple of 48 elements.
+--
+-- @since 0.11.0
+--
+data Tuple48 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1)
+
+-- | A tuple of 49 elements.
+--
+-- @since 0.11.0
+--
+data Tuple49 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1)
+
+-- | A tuple of 50 elements.
+--
+-- @since 0.11.0
+--
+data Tuple50 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1)
+
+-- | A tuple of 51 elements.
+--
+-- @since 0.11.0
+--
+data Tuple51 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1)
+
+-- | A tuple of 52 elements.
+--
+-- @since 0.11.0
+--
+data Tuple52 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1)
+
+-- | A tuple of 53 elements.
+--
+-- @since 0.11.0
+--
+data Tuple53 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2)
+
+-- | A tuple of 54 elements.
+--
+-- @since 0.11.0
+--
+data Tuple54 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2)
+
+-- | A tuple of 55 elements.
+--
+-- @since 0.11.0
+--
+data Tuple55 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2)
+
+-- | A tuple of 56 elements.
+--
+-- @since 0.11.0
+--
+data Tuple56 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2)
+
+-- | A tuple of 57 elements.
+--
+-- @since 0.11.0
+--
+data Tuple57 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2)
+
+-- | A tuple of 58 elements.
+--
+-- @since 0.11.0
+--
+data Tuple58 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2)
+
+-- | A tuple of 59 elements.
+--
+-- @since 0.11.0
+--
+data Tuple59 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2)
+
+-- | A tuple of 60 elements.
+--
+-- @since 0.11.0
+--
+data Tuple60 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2)
+
+-- | A tuple of 61 elements.
+--
+-- @since 0.11.0
+--
+data Tuple61 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2)
+
+-- | A tuple of 62 elements.
+--
+-- @since 0.11.0
+--
+data Tuple62 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2)
+
+-- | A tuple of 63 elements.
+--
+-- @since 0.11.0
+--
+data Tuple63 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2)
+
+-- | A tuple of 64 elements.
+--
+-- @since 0.11.0
+--
+data Tuple64 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2
+ = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,
+ r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2)
diff --git a/GHC/Types.hs b/GHC/Types.hs
--- a/GHC/Types.hs
+++ b/GHC/Types.hs
@@ -1,239 +1,3677 @@
{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples,
- RoleAnnotations #-}
------------------------------------------------------------------------------
--- |
--- Module : GHC.Types
--- Copyright : (c) The University of Glasgow 2009
--- License : see libraries/ghc-prim/LICENSE
---
--- Maintainer : cvs-ghc@haskell.org
--- Stability : internal
--- Portability : non-portable (GHC Extensions)
---
--- GHC type definitions.
--- Use GHC.Exts from the base package instead of importing this
--- module directly.
---
------------------------------------------------------------------------------
-
-module GHC.Types (
- Bool(..), Char(..), Int(..), Word(..),
- Float(..), Double(..),
- Ordering(..), IO(..),
- isTrue#,
- SPEC(..),
- Coercible,
- ) where
-
-import GHC.Prim
-
-
-infixr 5 :
-
-data [] a = [] | a : [a]
-
-data {-# CTYPE "HsBool" #-} Bool = False | True
-
-{- | The character type 'Char' is an enumeration whose values represent
-Unicode (or equivalently ISO\/IEC 10646) characters (see
- for details). This set extends the ISO 8859-1
-(Latin-1) character set (the first 256 characters), which is itself an extension
-of the ASCII character set (the first 128 characters). A character literal in
-Haskell has type 'Char'.
-
-To convert a 'Char' to or from the corresponding 'Int' value defined
-by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the
-'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr').
--}
-data {-# CTYPE "HsChar" #-} Char = C# Char#
-
--- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.
--- The exact range for a given implementation can be determined by using
--- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.
-data {-# CTYPE "HsInt" #-} Int = I# Int#
-
--- |A 'Word' is an unsigned integral type, with the same size as 'Int'.
-data {-# CTYPE "HsWord" #-} Word = W# Word#
-
--- | Single-precision floating point numbers.
--- It is desirable that this type be at least equal in range and precision
--- to the IEEE single-precision type.
-data {-# CTYPE "HsFloat" #-} Float = F# Float#
-
--- | Double-precision floating point numbers.
--- It is desirable that this type be at least equal in range and precision
--- to the IEEE double-precision type.
-data {-# CTYPE "HsDouble" #-} Double = D# Double#
-
-data Ordering = LT | EQ | GT
-
-{- |
-A value of type @'IO' a@ is a computation which, when performed,
-does some I\/O before returning a value of type @a@.
-
-There is really only one way to \"perform\" an I\/O action: bind it to
-@Main.main@ in your program. When your program is run, the I\/O will
-be performed. It isn't possible to perform I\/O from an arbitrary
-function, unless that function is itself in the 'IO' monad and called
-at some point, directly or indirectly, from @Main.main@.
-
-'IO' is a monad, so 'IO' actions can be combined using either the do-notation
-or the '>>' and '>>=' operations from the 'Monad' class.
--}
-newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
-type role IO representational
-{-
-The above role annotation is redundant but is included because this role
-is significant in the normalisation of FFI types. Specifically, if this
-role were to become nominal (which would be very strange, indeed!), changes
-elsewhere in GHC would be necessary. See [FFI type roles] in TcForeign.
--}
-
-{-
-Note [Kind-changing of (~) and Coercible]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-(~) and Coercible are tricky to define. To the user, they must appear as
-constraints, but we cannot define them as such in Haskell. But we also cannot
-just define them only in GHC.Prim (like (->)), because we need a real module
-for them, e.g. to compile the constructor's info table.
-
-Furthermore the type of MkCoercible cannot be written in Haskell
-(no syntax for ~#R).
-
-So we define them as regular data types in GHC.Types, and do magic in TysWiredIn,
-inside GHC, to change the kind and type.
--}
-
-
--- | A data constructor used to box up all unlifted equalities
---
--- The type constructor is special in that GHC pretends that it
--- has kind (? -> ? -> Fact) rather than (* -> * -> *)
-data (~) a b = Eq# ((~#) a b)
-
-
--- | This two-parameter class has instances for types @a@ and @b@ if
--- the compiler can infer that they have the same representation. This class
--- does not have regular instances; instead they are created on-the-fly during
--- type-checking. Trying to manually declare an instance of @Coercible@
--- is an error.
---
--- Nevertheless one can pretend that the following three kinds of instances
--- exist. First, as a trivial base-case:
---
--- @instance a a@
---
--- Furthermore, for every type constructor there is
--- an instance that allows to coerce under the type constructor. For
--- example, let @D@ be a prototypical type constructor (@data@ or
--- @newtype@) with three type arguments, which have roles @nominal@,
--- @representational@ resp. @phantom@. Then there is an instance of
--- the form
---
--- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@
---
--- Note that the @nominal@ type arguments are equal, the
--- @representational@ type arguments can differ, but need to have a
--- @Coercible@ instance themself, and the @phantom@ type arguments can be
--- changed arbitrarily.
---
--- The third kind of instance exists for every @newtype NT = MkNT T@ and
--- comes in two variants, namely
---
--- @instance Coercible a T => Coercible a NT@
---
--- @instance Coercible T b => Coercible NT b@
---
--- This instance is only usable if the constructor @MkNT@ is in scope.
---
--- If, as a library author of a type constructor like @Set a@, you
--- want to prevent a user of your module to write
--- @coerce :: Set T -> Set NT@,
--- you need to set the role of @Set@\'s type parameter to @nominal@,
--- by writing
---
--- @type role Set nominal@
---
--- For more details about this feature, please refer to
---
--- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
---
--- @since 4.7.0.0
-data Coercible a b = MkCoercible ((~#) a b)
--- It's really ~R# (representational equality), not ~#,
--- but * we don't yet have syntax for ~R#,
--- * the compiled code is the same either way
--- * TysWiredIn has the truthful types
--- Also see Note [Kind-changing of (~) and Coercible]
-
--- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False
--- if it is 0#.
-
-{-# INLINE isTrue# #-}
-isTrue# :: Int# -> Bool -- See Note [Optimizing isTrue#]
-isTrue# x = tagToEnum# x
-
--- Note [Optimizing isTrue#]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
---
--- Current definition of isTrue# is a temporary workaround. We would like to
--- have functions isTrue# and isFalse# defined like this:
---
--- isTrue# :: Int# -> Bool
--- isTrue# 1# = True
--- isTrue# _ = False
---
--- isFalse# :: Int# -> Bool
--- isFalse# 0# = True
--- isFalse# _ = False
---
--- These functions would allow us to safely check if a tag can represent True
--- or False. Using isTrue# and isFalse# as defined above will not introduce
--- additional case into the code. When we scrutinize return value of isTrue#
--- or isFalse#, either explicitly in a case expression or implicitly in a guard,
--- the result will always be a single case expression (given that optimizations
--- are turned on). This results from case-of-case transformation. Consider this
--- code (this is both valid Haskell and Core):
---
--- case isTrue# (a ># b) of
--- True -> e1
--- False -> e2
---
--- Inlining isTrue# gives:
---
--- case (case (a ># b) of { 1# -> True; _ -> False } ) of
--- True -> e1
--- False -> e2
---
--- Case-of-case transforms that to:
---
--- case (a ># b) of
--- 1# -> case True of
--- True -> e1
--- False -> e2
--- _ -> case False of
--- True -> e1
--- False -> e2
---
--- Which is then simplified by case-of-known-constructor:
---
--- case (a ># b) of
--- 1# -> e1
--- _ -> e2
---
--- While we get good Core here, the code generator will generate very bad Cmm
--- if e1 or e2 do allocation. It will push heap checks into case alternatives
--- which results in about 2.5% increase in code size. Until this is improved we
--- just make isTrue# an alias to tagToEnum#. This is a temporary solution (if
--- you're reading this in 2023 then things went wrong). See #8326.
---
-
--- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform
--- the compiler when to be particularly aggressive. In particular, it
--- tells GHC to specialize regardless of size or the number of
--- specializations. However, not all loops fall into this category.
---
--- Libraries can specify this by using 'SPEC' data type to inform which
--- loops should be aggressively specialized.
-data SPEC = SPEC | SPEC2
+ MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators,
+ PolyKinds, NegativeLiterals, DataKinds, ScopedTypeVariables,
+ TypeApplications, StandaloneKindSignatures, GADTs,
+ FlexibleInstances, UndecidableInstances, UnboxedSums #-}
+-- NegativeLiterals: see Note [Fixity of (->)]
+{-# OPTIONS_HADDOCK print-explicit-runtime-reps #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Types
+-- Copyright : (c) The University of Glasgow 2009
+-- License : see libraries/ghc-prim/LICENSE
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Stability : internal
+-- Portability : non-portable (GHC Extensions)
+--
+-- GHC type definitions.
+-- Use GHC.Exts from the base package instead of importing this
+-- module directly.
+--
+-----------------------------------------------------------------------------
+
+module GHC.Types (
+ -- * Built-in types
+ Bool(..), Char(..), Int(..), Word(..),
+ Float(..), Double(..),
+ Ordering(..), IO(..),
+
+ List, -- List( [], (:) )
+ -- List constructors are not exported
+ -- because they are built-in syntax
+
+ isTrue#,
+ SPEC(..),
+ Symbol,
+ Any,
+
+ -- * Type equality
+ type (~), type (~~), Coercible,
+
+ -- * Representation polymorphism
+ TYPE, CONSTRAINT,
+ Levity(..), RuntimeRep(..),
+ LiftedRep, UnliftedRep,
+ Type, UnliftedType, Constraint,
+ -- The historical type * should ideally be written as
+ -- `type *`, without the parentheses. But that's a true
+ -- pain to parse, and for little gain.
+ ZeroBitRep, ZeroBitType,
+ VecCount(..), VecElem(..),
+ Void#,
+
+ -- * Boxing constructors
+ DictBox( MkDictBox ),
+ WordBox( MkWordBox), IntBox( MkIntBox),
+ FloatBox( MkFloatBox), DoubleBox( MkDoubleBox),
+
+ -- * Multiplicity types
+ Multiplicity(..), MultMul,
+
+ -- * Runtime type representation
+ Module(..), TrName(..), TyCon(..), TypeLitSort(..),
+ KindRep(..), KindBndr,
+
+ -- * Unboxed tuples
+ Unit#,
+ Solo#(..),
+ Tuple0#,
+ Tuple1#,
+ Tuple2#,
+ Tuple3#,
+ Tuple4#,
+ Tuple5#,
+ Tuple6#,
+ Tuple7#,
+ Tuple8#,
+ Tuple9#,
+ Tuple10#,
+ Tuple11#,
+ Tuple12#,
+ Tuple13#,
+ Tuple14#,
+ Tuple15#,
+ Tuple16#,
+ Tuple17#,
+ Tuple18#,
+ Tuple19#,
+ Tuple20#,
+ Tuple21#,
+ Tuple22#,
+ Tuple23#,
+ Tuple24#,
+ Tuple25#,
+ Tuple26#,
+ Tuple27#,
+ Tuple28#,
+ Tuple29#,
+ Tuple30#,
+ Tuple31#,
+ Tuple32#,
+ Tuple33#,
+ Tuple34#,
+ Tuple35#,
+ Tuple36#,
+ Tuple37#,
+ Tuple38#,
+ Tuple39#,
+ Tuple40#,
+ Tuple41#,
+ Tuple42#,
+ Tuple43#,
+ Tuple44#,
+ Tuple45#,
+ Tuple46#,
+ Tuple47#,
+ Tuple48#,
+ Tuple49#,
+ Tuple50#,
+ Tuple51#,
+ Tuple52#,
+ Tuple53#,
+ Tuple54#,
+ Tuple55#,
+ Tuple56#,
+ Tuple57#,
+ Tuple58#,
+ Tuple59#,
+ Tuple60#,
+ Tuple61#,
+ Tuple62#,
+ Tuple63#,
+ Tuple64#,
+
+ -- * Unboxed sums
+ Sum2#,
+ Sum3#,
+ Sum4#,
+ Sum5#,
+ Sum6#,
+ Sum7#,
+ Sum8#,
+ Sum9#,
+ Sum10#,
+ Sum11#,
+ Sum12#,
+ Sum13#,
+ Sum14#,
+ Sum15#,
+ Sum16#,
+ Sum17#,
+ Sum18#,
+ Sum19#,
+ Sum20#,
+ Sum21#,
+ Sum22#,
+ Sum23#,
+ Sum24#,
+ Sum25#,
+ Sum26#,
+ Sum27#,
+ Sum28#,
+ Sum29#,
+ Sum30#,
+ Sum31#,
+ Sum32#,
+ Sum33#,
+ Sum34#,
+ Sum35#,
+ Sum36#,
+ Sum37#,
+ Sum38#,
+ Sum39#,
+ Sum40#,
+ Sum41#,
+ Sum42#,
+ Sum43#,
+ Sum44#,
+ Sum45#,
+ Sum46#,
+ Sum47#,
+ Sum48#,
+ Sum49#,
+ Sum50#,
+ Sum51#,
+ Sum52#,
+ Sum53#,
+ Sum54#,
+ Sum55#,
+ Sum56#,
+ Sum57#,
+ Sum58#,
+ Sum59#,
+ Sum60#,
+ Sum61#,
+ Sum62#,
+ Sum63#,
+
+ ) where
+
+import GHC.Prim
+
+infixr 5 :
+
+{- *********************************************************************
+* *
+ Functions
+* *
+********************************************************************* -}
+
+infixr -1 ->
+{-
+Note [Fixity of (->)]
+~~~~~~~~~~~~~~~~~~~~~
+This declaration is important for :info (->) command (issue #10145)
+1) The parser parses -> as if it had lower fixity than 0,
+ so we conventionally use -1 (issue #15235).
+2) Fixities outside the 0-9 range are exceptionally allowed
+ for (->) (see checkPrecP in RdrHsSyn)
+3) The negative fixity -1 must be parsed as a single token,
+ hence this module requires NegativeLiterals.
+-}
+
+-- | The regular function type
+type (->) = FUN 'Many
+-- See Note [Linear types] in Multiplicity
+
+{- *********************************************************************
+* *
+ Kinds
+* *
+********************************************************************* -}
+
+
+
+-- | The runtime representation of lifted types.
+type LiftedRep = 'BoxedRep 'Lifted
+
+-- | The runtime representation of unlifted types.
+type UnliftedRep = 'BoxedRep 'Unlifted
+
+-- | The runtime representation of a zero-width tuple,
+-- represented by no bits at all
+type ZeroBitRep = 'TupleRep '[]
+
+-------------------------
+-- | The kind of lifted constraints
+type Constraint = CONSTRAINT LiftedRep
+
+-- | The kind of types with lifted values. For example @Int :: Type@.
+type Type = TYPE LiftedRep
+
+-- | The kind of boxed, unlifted values, for example @Array#@ or a user-defined
+-- unlifted data type, using @-XUnliftedDataTypes@.
+type UnliftedType = TYPE UnliftedRep
+
+-- | The kind of the empty unboxed tuple type (# #)
+type ZeroBitType = TYPE ZeroBitRep
+
+-------------------------
+data Multiplicity = Many | One
+
+type family MultMul (a :: Multiplicity) (b :: Multiplicity) :: Multiplicity where
+ MultMul 'One x = x
+ MultMul x 'One = x
+ MultMul 'Many x = 'Many
+ MultMul x 'Many = 'Many
+
+{- *********************************************************************
+* *
+ Symbol
+* *
+********************************************************************* -}
+
+-- | (Kind) This is the kind of type-level symbols.
+data Symbol
+
+-- Symbol is declared here because class IP needs it
+
+{- *********************************************************************
+* *
+ Any
+* *
+********************************************************************* -}
+
+-- | The type constructor @Any :: forall k. k@ is a type to which you can unsafely coerce any type, and back.
+--
+-- For @unsafeCoerce@ this means for all lifted types @t@ that
+-- @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent to @x@ and safe.
+--
+-- The same is true for *all* types when using
+-- @
+-- unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)
+-- (a :: TYPE r1) (b :: TYPE r2).
+-- a -> b
+-- @
+-- but /only/ if you instantiate @r1@ and @r2@ to the /same/ runtime representation.
+-- For example using @(unsafeCoerce# :: forall (a :: TYPE IntRep) (b :: TYPE IntRep). a -> b) x@
+-- is fine, but @(unsafeCoerce# :: forall (a :: TYPE IntRep) (b :: TYPE FloatRep). a -> b)@
+-- will likely cause seg-faults or worse.
+-- For this resason, users should always prefer unsafeCoerce over unsafeCoerce# when possible.
+--
+-- Here are some more examples:
+-- @
+-- bad_a1 :: Any @(TYPE 'IntRep)
+-- bad_a1 = unsafeCoerce# True
+--
+-- bad_a2 :: Any @(TYPE ('BoxedRep 'UnliftedRep))
+-- bad_a2 = unsafeCoerce# True
+-- @
+-- Here @bad_a1@ is bad because we started with @True :: (Bool :: Type)@, represented by a boxed heap pointer,
+-- and coerced it to @a1 :: Any @(TYPE 'IntRep)@, whose representation is a non-pointer integer.
+-- That's why we had to use `unsafeCoerce#`; it is really unsafe because it can change representations.
+-- Similarly @bad_a2@ is bad because although both @True@ and @bad_a2@ are represented by a heap pointer,
+-- @True@ is lifted but @bad_a2@ is not; bugs here may be rather subtle.
+--
+-- If you must use unsafeCoerce# to cast to `Any`, type annotations are recommended
+-- to make sure that @Any@ has the correct kind. As casting between different runtimereps is
+-- unsound. For example to cast a @ByteArray#@ to @Any@ you might use:
+-- @
+-- unsafeCoerce# b :: (Any :: TYPE ('BoxedRep 'Unlifted))
+-- @
+type family Any :: k where { }
+-- See Note [Any types] in GHC.Builtin.Types. Also, for a bit of history on Any see
+-- #10886. Note that this must be a *closed* type family: we need to ensure
+-- that this can't reduce to a `data` type for the results discussed in
+-- Note [Any types].
+
+{- *********************************************************************
+* *
+ Lists
+
+ NB: lists are built-in syntax, and hence not explicitly exported
+* *
+********************************************************************* -}
+
+-- | The builtin linked list type.
+--
+-- In Haskell, lists are one of the most important data types as they are
+-- often used analogous to loops in imperative programming languages.
+-- These lists are singly linked, which makes them unsuited for operations
+-- that require \(\mathcal{O}(1)\) access. Instead, they are intended to
+-- be traversed.
+--
+-- You can use @List a@ or @[a]@ in type signatures:
+--
+-- > length :: [a] -> Int
+--
+-- or
+--
+-- > length :: List a -> Int
+--
+-- They are fully equivalent, and @List a@ will be normalised to @[a]@.
+--
+-- ==== Usage
+--
+-- Lists are constructed recursively using the right-associative constructor operator (or /cons/)
+-- @(:) :: a -> [a] -> [a]@, which prepends an element to a list,
+-- and the empty list @[]@.
+--
+-- @
+-- (1 : 2 : 3 : []) == (1 : (2 : (3 : []))) == [1, 2, 3]
+-- @
+--
+-- Lists can also be constructed using list literals
+-- of the form @[x_1, x_2, ..., x_n]@
+-- which are syntactic sugar and, unless @-XOverloadedLists@ is enabled,
+-- are translated into uses of @(:)@ and @[]@
+--
+-- 'Data.String.String' literals, like @"I 💜 hs"@, are translated into
+-- Lists of characters, @[\'I\', \' \', \'💜\', \' \', \'h\', \'s\']@.
+--
+-- ==== __Implementation__
+--
+-- Internally and in memory, all the above are represented like this,
+-- with arrows being pointers to locations in memory.
+--
+-- > â•â”€â”€â”€â”¬â”€â”€â”€â”¬â”€â”€â•® â•â”€â”€â”€â”¬â”€â”€â”€â”¬â”€â”€â•® â•â”€â”€â”€â”¬â”€â”€â”€â”¬â”€â”€â•® â•â”€â”€â”€â”€â•®
+-- > │(:)│ │ ─┼──>│(:)│ │ ─┼──>│(:)│ │ ─┼──>│ [] │
+-- > ╰───┴─┼─┴──╯ ╰───┴─┼─┴──╯ ╰───┴─┼─┴──╯ ╰────╯
+-- > v v v
+-- > 1 2 3
+--
+-- ==== __Examples__
+--
+-- @
+-- >>> [\'H\', \'a\', \'s\', \'k\', \'e\', \'l\', \'l\']
+-- \"Haskell\"
+-- @
+--
+-- @
+-- >>> 1 : [4, 1, 5, 9]
+-- [1,4,1,5,9]
+-- @
+--
+-- @
+-- >>> [] : [] : []
+-- [[],[]]
+-- @
+--
+-- @since 0.10.0
+--
+data List a = [] | a : List a
+
+
+{- *********************************************************************
+* *
+ Ordering
+* *
+********************************************************************* -}
+
+data Ordering = LT | EQ | GT
+
+
+{- *********************************************************************
+* *
+ Int, Char, Word, Float, Double
+* *
+********************************************************************* -}
+
+{- | The character type 'Char' represents Unicode codespace
+and its elements are code points as in definitions
+[D9 and D10 of the Unicode Standard](https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf#G2212).
+
+Character literals in Haskell are single-quoted: @\'Q\'@, @\'Я\'@ or @\'Ω\'@.
+To represent a single quote itself use @\'\\''@, and to represent a backslash
+use @\'\\\\\'@. The full grammar can be found in the section 2.6 of the
+[Haskell 2010 Language Report](https://www.haskell.org/definition/haskell2010.pdf#section.2.6).
+
+To specify a character by its code point one can use decimal, hexadecimal
+or octal notation: @\'\\65\'@, @\'\\x41\'@ and @\'\\o101\'@ are all alternative forms
+of @\'A\'@. The largest code point is @\'\\x10ffff\'@.
+
+There is a special escape syntax for ASCII control characters:
+
++-------------+-------------------+---------------------------+
+| Escape | Alternatives | Meaning |
++=============+===================+===========================+
+| @'\\NUL'@ | @'\\0'@ | null character |
++-------------+-------------------+---------------------------+
+| @'\\SOH'@ | @'\\1'@ | start of heading |
++-------------+-------------------+---------------------------+
+| @'\\STX'@ | @'\\2'@ | start of text |
++-------------+-------------------+---------------------------+
+| @'\\ETX'@ | @'\\3'@ | end of text |
++-------------+-------------------+---------------------------+
+| @'\\EOT'@ | @'\\4'@ | end of transmission |
++-------------+-------------------+---------------------------+
+| @'\\ENQ'@ | @'\\5'@ | enquiry |
++-------------+-------------------+---------------------------+
+| @'\\ACK'@ | @'\\6'@ | acknowledge |
++-------------+-------------------+---------------------------+
+| @'\\BEL'@ | @'\\7'@, @'\\a'@ | bell (alert) |
++-------------+-------------------+---------------------------+
+| @'\\BS'@ | @'\\8'@, @'\\b'@ | backspace |
++-------------+-------------------+---------------------------+
+| @'\\HT'@ | @'\\9'@, @'\\t'@ | horizontal tab |
++-------------+-------------------+---------------------------+
+| @'\\LF'@ | @'\\10'@, @'\\n'@ | line feed (new line) |
++-------------+-------------------+---------------------------+
+| @'\\VT'@ | @'\\11'@, @'\\v'@ | vertical tab |
++-------------+-------------------+---------------------------+
+| @'\\FF'@ | @'\\12'@, @'\\f'@ | form feed |
++-------------+-------------------+---------------------------+
+| @'\\CR'@ | @'\\13'@, @'\\r'@ | carriage return |
++-------------+-------------------+---------------------------+
+| @'\\SO'@ | @'\\14'@ | shift out |
++-------------+-------------------+---------------------------+
+| @'\\SI'@ | @'\\15'@ | shift in |
++-------------+-------------------+---------------------------+
+| @'\\DLE'@ | @'\\16'@ | data link escape |
++-------------+-------------------+---------------------------+
+| @'\\DC1'@ | @'\\17'@ | device control 1 |
++-------------+-------------------+---------------------------+
+| @'\\DC2'@ | @'\\18'@ | device control 2 |
++-------------+-------------------+---------------------------+
+| @'\\DC3'@ | @'\\19'@ | device control 3 |
++-------------+-------------------+---------------------------+
+| @'\\DC4'@ | @'\\20'@ | device control 4 |
++-------------+-------------------+---------------------------+
+| @'\\NAK'@ | @'\\21'@ | negative acknowledge |
++-------------+-------------------+---------------------------+
+| @'\\SYN'@ | @'\\22'@ | synchronous idle |
++-------------+-------------------+---------------------------+
+| @'\\ETB'@ | @'\\23'@ | end of transmission block |
++-------------+-------------------+---------------------------+
+| @'\\CAN'@ | @'\\24'@ | cancel |
++-------------+-------------------+---------------------------+
+| @'\\EM'@ | @'\\25'@ | end of medium |
++-------------+-------------------+---------------------------+
+| @'\\SUB'@ | @'\\26'@ | substitute |
++-------------+-------------------+---------------------------+
+| @'\\ESC'@ | @'\\27'@ | escape |
++-------------+-------------------+---------------------------+
+| @'\\FS'@ | @'\\28'@ | file separator |
++-------------+-------------------+---------------------------+
+| @'\\GS'@ | @'\\29'@ | group separator |
++-------------+-------------------+---------------------------+
+| @'\\RS'@ | @'\\30'@ | record separator |
++-------------+-------------------+---------------------------+
+| @'\\US'@ | @'\\31'@ | unit separator |
++-------------+-------------------+---------------------------+
+| @'\\SP'@ | @'\\32'@, @' '@ | space |
++-------------+-------------------+---------------------------+
+| @'\\DEL'@ | @'\\127'@ | delete |
++-------------+-------------------+---------------------------+
+
+[Data.Char](https://hackage.haskell.org/package/base/docs/Data-Char.html)
+provides utilities to work with 'Char'.
+
+-}
+data {-# CTYPE "HsChar" #-} Char = C# Char#
+
+-- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.
+-- The exact range for a given implementation can be determined by using
+-- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.
+data {-# CTYPE "HsInt" #-} Int = I# Int#
+
+-- |A 'Word' is an unsigned integral type, with the same size as 'Int'.
+data {-# CTYPE "HsWord" #-} Word = W# Word#
+
+-- | Single-precision floating point numbers.
+-- It is desirable that this type be at least equal in range and precision
+-- to the IEEE single-precision type.
+data {-# CTYPE "HsFloat" #-} Float = F# Float#
+
+-- | Double-precision floating point numbers.
+-- It is desirable that this type be at least equal in range and precision
+-- to the IEEE double-precision type.
+data {-# CTYPE "HsDouble" #-} Double = D# Double#
+
+
+{- *********************************************************************
+* *
+ IO
+* *
+********************************************************************* -}
+
+{- |
+A value of type @'IO' a@ is a computation which, when performed,
+does some I\/O before returning a value of type @a@.
+
+There is really only one way to \"perform\" an I\/O action: bind it to
+@Main.main@ in your program. When your program is run, the I\/O will
+be performed. It isn't possible to perform I\/O from an arbitrary
+function, unless that function is itself in the 'IO' monad and called
+at some point, directly or indirectly, from @Main.main@.
+
+'IO' is a monad, so 'IO' actions can be combined using either the do-notation
+or the 'Prelude.>>' and 'Prelude.>>=' operations from the 'Prelude.Monad'
+class.
+-}
+newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
+
+
+{- *********************************************************************
+* *
+ (~) and Coercible
+
+* *
+********************************************************************* -}
+
+{-
+Note [Kind-changing of (~) and Coercible]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+(~) and Coercible are tricky to define. To the user, they must appear as
+constraints, but we cannot define them as such in Haskell. But we also cannot
+just define them only in GHC.Prim (like (->)), because we need a real module
+for them, e.g. to compile the constructor's info table.
+
+Furthermore the type of MkCoercible cannot be written in Haskell
+(no syntax for ~#R).
+
+So we define them as regular data types in GHC.Types, and do magic in GHC.Builtin.Types,
+inside GHC, to change the kind and type.
+-}
+
+
+-- | Lifted, heterogeneous equality. By lifted, we mean that it
+-- can be bogus (deferred type error). By heterogeneous, the two
+-- types @a@ and @b@ might have different kinds. Because @~~@ can
+-- appear unexpectedly in error messages to users who do not care
+-- about the difference between heterogeneous equality @~~@ and
+-- homogeneous equality @~@, this is printed as @~@ unless
+-- @-fprint-equality-relations@ is set.
+--
+-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~~:'.
+class a ~~ b
+
+ -- See also Note [The equality types story] in GHC.Builtin.Types.Prim
+
+-- | Lifted, homogeneous equality. By lifted, we mean that it
+-- can be bogus (deferred type error). By homogeneous, the two
+-- types @a@ and @b@ must have the same kinds.
+
+-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~:'.
+class a ~ b
+
+infix 4 ~, ~~
+ -- See also Note [The equality types story] in GHC.Builtin.Types.Prim
+
+-- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ if
+-- the compiler can infer that they have the same representation. This class
+-- does not have regular instances; instead they are created on-the-fly during
+-- type-checking. Trying to manually declare an instance of @Coercible@
+-- is an error.
+--
+-- Nevertheless one can pretend that the following three kinds of instances
+-- exist. First, as a trivial base-case:
+--
+-- @instance Coercible a a@
+--
+-- Furthermore, for every type constructor there is
+-- an instance that allows to coerce under the type constructor. For
+-- example, let @D@ be a prototypical type constructor (@data@ or
+-- @newtype@) with three type arguments, which have roles @nominal@,
+-- @representational@ resp. @phantom@. Then there is an instance of
+-- the form
+--
+-- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@
+--
+-- Note that the @nominal@ type arguments are equal, the
+-- @representational@ type arguments can differ, but need to have a
+-- @Coercible@ instance themself, and the @phantom@ type arguments can be
+-- changed arbitrarily.
+--
+-- The third kind of instance exists for every @newtype NT = MkNT T@ and
+-- comes in two variants, namely
+--
+-- @instance Coercible a T => Coercible a NT@
+--
+-- @instance Coercible T b => Coercible NT b@
+--
+-- This instance is only usable if the constructor @MkNT@ is in scope.
+--
+-- If, as a library author of a type constructor like @Set a@, you
+-- want to prevent a user of your module to write
+-- @coerce :: Set T -> Set NT@,
+-- you need to set the role of @Set@\'s type parameter to @nominal@,
+-- by writing
+--
+-- @type role Set nominal@
+--
+-- For more details about this feature, please refer to
+--
+-- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
+--
+-- @since 0.4.0
+class Coercible (a :: k) (b :: k)
+ -- See also Note [The equality types story] in GHC.Builtin.Types.Prim
+
+{- *********************************************************************
+* *
+ Bool, and isTrue#
+* *
+********************************************************************* -}
+
+data {-# CTYPE "HsBool" #-} Bool = False | True
+
+{-# INLINE isTrue# #-}
+-- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False
+-- if it is 0#.
+isTrue# :: Int# -> Bool -- See Note [Optimizing isTrue#]
+isTrue# x = tagToEnum# x
+
+{- Note [Optimizing isTrue#]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Current definition of isTrue# is a temporary workaround. We would like to
+have functions isTrue# and isFalse# defined like this:
+
+ isTrue# :: Int# -> Bool
+ isTrue# 1# = True
+ isTrue# _ = False
+
+ isFalse# :: Int# -> Bool
+ isFalse# 0# = True
+ isFalse# _ = False
+
+These functions would allow us to safely check if a tag can represent True
+or False. Using isTrue# and isFalse# as defined above will not introduce
+additional case into the code. When we scrutinize return value of isTrue#
+or isFalse#, either explicitly in a case expression or implicitly in a guard,
+the result will always be a single case expression (given that optimizations
+are turned on). This results from case-of-case transformation. Consider this
+code (this is both valid Haskell and Core):
+
+case isTrue# (a ># b) of
+ True -> e1
+ False -> e2
+
+Inlining isTrue# gives:
+
+case (case (a ># b) of { 1# -> True; _ -> False } ) of
+ True -> e1
+ False -> e2
+
+Case-of-case transforms that to:
+
+case (a ># b) of
+ 1# -> case True of
+ True -> e1
+ False -> e2
+ _ -> case False of
+ True -> e1
+ False -> e2
+
+Which is then simplified by case-of-known-constructor:
+
+case (a ># b) of
+ 1# -> e1
+ _ -> e2
+
+While we get good Core here, the code generator will generate very bad Cmm
+if e1 or e2 do allocation. It will push heap checks into case alternatives
+which results in about 2.5% increase in code size. Until this is improved we
+just make isTrue# an alias to tagToEnum#. This is a temporary solution (if
+you're reading this in 2023 then things went wrong). See #8326.
+-}
+
+
+{- *********************************************************************
+* *
+ SPEC
+* *
+********************************************************************* -}
+
+-- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform
+-- the compiler when to be particularly aggressive. In particular, it
+-- tells GHC to specialize regardless of size or the number of
+-- specializations. However, not all loops fall into this category.
+--
+-- Libraries can specify this by using 'SPEC' data type to inform which
+-- loops should be aggressively specialized. For example,
+-- instead of
+--
+-- > loop x where loop arg = ...
+--
+-- write
+--
+-- > loop SPEC x where loop !_ arg = ...
+--
+-- There is no semantic difference between 'SPEC' and 'SPEC2',
+-- we just need a type with two constructors lest it is optimised away
+-- before @SpecConstr@.
+--
+-- This type is reexported from "GHC.Exts" since GHC 9.0 and @base-4.15@.
+-- For compatibility with earlier releases import it from "GHC.Types"
+-- in @ghc-prim@ package.
+--
+-- @since 0.3.1.0
+--
+data SPEC = SPEC | SPEC2
+
+
+{- *********************************************************************
+* *
+ Levity polymorphism
+* *
+********************************************************************* -}
+
+-- | Whether a boxed type is lifted or unlifted.
+data Levity = Lifted | Unlifted
+
+-- | GHC maintains a property that the kind of all inhabited types
+-- (as distinct from type constructors or type-level data) tells us
+-- the runtime representation of values of that type. This datatype
+-- encodes the choice of runtime value.
+-- Note that 'TYPE' is parameterised by 'RuntimeRep'; this is precisely
+-- what we mean by the fact that a type's kind encodes the runtime
+-- representation.
+--
+-- For boxed values (that is, values that are represented by a pointer),
+-- a further distinction is made, between lifted types (that contain ⊥),
+-- and unlifted ones (that don't).
+data RuntimeRep = VecRep VecCount VecElem -- ^ a SIMD vector type
+ | TupleRep [RuntimeRep] -- ^ An unboxed tuple of the given reps
+ | SumRep [RuntimeRep] -- ^ An unboxed sum of the given reps
+ | BoxedRep Levity -- ^ boxed; represented by a pointer
+ | IntRep -- ^ signed, word-sized value
+ | Int8Rep -- ^ signed, 8-bit value
+ | Int16Rep -- ^ signed, 16-bit value
+ | Int32Rep -- ^ signed, 32-bit value
+ | Int64Rep -- ^ signed, 64-bit value
+ | WordRep -- ^ unsigned, word-sized value
+ | Word8Rep -- ^ unsigned, 8-bit value
+ | Word16Rep -- ^ unsigned, 16-bit value
+ | Word32Rep -- ^ unsigned, 32-bit value
+ | Word64Rep -- ^ unsigned, 64-bit value
+ | AddrRep -- ^ A pointer, but /not/ to a Haskell value
+ | FloatRep -- ^ a 32-bit floating point number
+ | DoubleRep -- ^ a 64-bit floating point number
+
+-- RuntimeRep is intimately tied to TyCon.RuntimeRep (in GHC proper). See
+-- Note [RuntimeRep and PrimRep] in RepType.
+-- See also Note [Wiring in RuntimeRep] in GHC.Builtin.Types
+-- See also Note [TYPE and CONSTRAINT] in GHC.Builtin.Type.Prim
+
+-- | Length of a SIMD vector type
+data VecCount = Vec2
+ | Vec4
+ | Vec8
+ | Vec16
+ | Vec32
+ | Vec64
+-- Enum, Bounded instances in GHC.Enum
+
+-- | Element of a SIMD vector type
+data VecElem = Int8ElemRep
+ | Int16ElemRep
+ | Int32ElemRep
+ | Int64ElemRep
+ | Word8ElemRep
+ | Word16ElemRep
+ | Word32ElemRep
+ | Word64ElemRep
+ | FloatElemRep
+ | DoubleElemRep
+-- Enum, Bounded instances in GHC.Enum
+
+{-# DEPRECATED Void# "Void# is now an alias for the unboxed tuple (# #)." #-}
+type Void# = (# #)
+
+{- *********************************************************************
+* *
+ Boxing data constructors
+* *
+********************************************************************* -}
+
+-- These "boxing" data types allow us to wrap up a value of kind (TYPE rr)
+-- in a box of kind Type, for each rr.
+data LiftBox (a :: TYPE UnliftedRep) = MkLiftBox a
+
+data IntBox (a :: TYPE IntRep) = MkIntBox a
+data Int8Box (a :: TYPE Int8Rep) = MkInt8Box a
+data Int16Box (a :: TYPE Int16Rep) = MkInt16Box a
+data Int32Box (a :: TYPE Int32Rep) = MkInt32Box a
+data Int64Box (a :: TYPE Int64Rep) = MkInt64Box a
+
+data WordBox (a :: TYPE WordRep) = MkWordBox a
+data Word8Box (a :: TYPE Word8Rep) = MkWord8Box a
+data Word16Box (a :: TYPE Word16Rep) = MkWord16Box a
+data Word32Box (a :: TYPE Word32Rep) = MkWord32Box a
+data Word64Box (a :: TYPE Word64Rep) = MkWord64Box a
+
+data FloatBox (a :: TYPE FloatRep) = MkFloatBox a
+data DoubleBox (a :: TYPE DoubleRep) = MkDoubleBox a
+
+-- | Data type `Dict` provides a simple way to wrap up a (lifted)
+-- constraint as a type
+data DictBox c where
+ MkDictBox :: c => DictBox c
+
+
+{- *********************************************************************
+* *
+ Runtime representation of TyCon
+* *
+********************************************************************* -}
+
+{- Note [Runtime representation of modules and tycons]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We generate a binding for M.$modName and M.$tcT for every module M and
+data type T. Things to think about
+
+ - We want them to be economical on space; ideally pure data with no thunks.
+
+ - We do this for every module (except this module GHC.Types), so we can't
+ depend on anything else (eg string unpacking code)
+
+That's why we have these terribly low-level representations. The TrName
+type lets us use the TrNameS constructor when allocating static data;
+but we also need TrNameD for the case where we are deserialising a TyCon
+or Module (for example when deserialising a TypeRep), in which case we
+can't conveniently come up with an Addr#.
+-}
+
+#include "MachDeps.h"
+
+data Module = Module
+ TrName -- ^ Package name
+ TrName -- ^ Module name
+
+data TrName
+ = TrNameS Addr# -- ^ Static
+ | TrNameD [Char] -- ^ Dynamic
+
+-- | A de Bruijn index for a binder within a 'KindRep'.
+type KindBndr = Int
+
+-- | The representation produced by GHC for conjuring up the kind of a
+-- 'Data.Typeable.TypeRep'.
+
+-- See Note [Representing TyCon kinds: KindRep] in GHC.Tc.Instance.Typeable.
+data KindRep = KindRepTyConApp TyCon [KindRep]
+ | KindRepVar !KindBndr
+ | KindRepApp KindRep KindRep
+ | KindRepFun KindRep KindRep
+ | KindRepTYPE !RuntimeRep
+ | KindRepTypeLitS TypeLitSort Addr#
+ | KindRepTypeLitD TypeLitSort [Char]
+
+data TypeLitSort = TypeLitSymbol
+ | TypeLitNat
+ | TypeLitChar
+
+-- Show instance for TyCon found in GHC.Show
+data TyCon = TyCon Word64# -- ^ Fingerprint (high)
+ Word64# -- ^ Fingerprint (low)
+ Module -- ^ Module in which this is defined
+ TrName -- ^ Type constructor name
+ Int# -- ^ How many kind variables do we accept?
+ KindRep -- ^ A representation of the type's kind
+
+{- *********************************************************************
+* *
+ Unboxed tuples and sums
+* *
+********************************************************************* -}
+
+type Unit# :: TYPE (TupleRep '[])
+data Unit# = (# #)
+
+type Solo# :: TYPE rep -> TYPE (TupleRep '[rep])
+data Solo# a = MkSolo# a
+
+type Tuple0# = Unit#
+type Tuple1# = Solo#
+
+type Tuple2# :: TYPE r1 -> TYPE r2 -> TYPE (TupleRep [r1, r2])
+data Tuple2# a b =
+ (# a,b #)
+type Tuple3# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE (TupleRep [r1, r2, r3])
+data Tuple3# a b c =
+ (# a,b,c #)
+type Tuple4# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE (TupleRep [r1, r2, r3, r4])
+data Tuple4# a b c d =
+ (# a,b,c,d #)
+type Tuple5# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE (TupleRep [r1, r2, r3, r4, r5])
+data Tuple5# a b c d e =
+ (# a,b,c,d,e #)
+type Tuple6# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6])
+data Tuple6# a b c d e f =
+ (# a,b,c,d,e,f #)
+type Tuple7# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7])
+data Tuple7# a b c d e f g =
+ (# a,b,c,d,e,f,g #)
+type Tuple8# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8])
+data Tuple8# a b c d e f g h =
+ (# a,b,c,d,e,f,g,h #)
+type Tuple9# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9])
+data Tuple9# a b c d e f g h i =
+ (# a,b,c,d,e,f,g,h,i #)
+type Tuple10# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10])
+data Tuple10# a b c d e f g h i j =
+ (# a,b,c,d,e,f,g,h,i,j #)
+type Tuple11# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11])
+data Tuple11# a b c d e f g h i j k =
+ (# a,b,c,d,e,f,g,h,i,j,k #)
+type Tuple12# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12])
+data Tuple12# a b c d e f g h i j k l =
+ (# a,b,c,d,e,f,g,h,i,j,k,l #)
+type Tuple13# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13])
+data Tuple13# a b c d e f g h i j k l m =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m #)
+type Tuple14# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14])
+data Tuple14# a b c d e f g h i j k l m n =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n #)
+type Tuple15# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15])
+data Tuple15# a b c d e f g h i j k l m n o =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o #)
+type Tuple16# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16])
+data Tuple16# a b c d e f g h i j k l m n o p =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p #)
+type Tuple17# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17])
+data Tuple17# a b c d e f g h i j k l m n o p q =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q #)
+type Tuple18# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18])
+data Tuple18# a b c d e f g h i j k l m n o p q r =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r #)
+type Tuple19# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19])
+data Tuple19# a b c d e f g h i j k l m n o p q r s =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s #)
+type Tuple20# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20])
+data Tuple20# a b c d e f g h i j k l m n o p q r s t =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t #)
+type Tuple21# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21])
+data Tuple21# a b c d e f g h i j k l m n o p q r s t u =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u #)
+type Tuple22# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22])
+data Tuple22# a b c d e f g h i j k l m n o p q r s t u v =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v #)
+type Tuple23# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23])
+data Tuple23# a b c d e f g h i j k l m n o p q r s t u v w =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w #)
+type Tuple24# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24])
+data Tuple24# a b c d e f g h i j k l m n o p q r s t u v w x =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x #)
+type Tuple25# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25])
+data Tuple25# a b c d e f g h i j k l m n o p q r s t u v w x y =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y #)
+type Tuple26# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26])
+data Tuple26# a b c d e f g h i j k l m n o p q r s t u v w x y z =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z #)
+type Tuple27# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27])
+data Tuple27# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1 #)
+type Tuple28# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28])
+data Tuple28# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1 #)
+type Tuple29# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29])
+data Tuple29# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1 #)
+type Tuple30# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30])
+data Tuple30# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1 #)
+type Tuple31# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31])
+data Tuple31# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1 #)
+type Tuple32# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32])
+data Tuple32# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1 #)
+type Tuple33# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33])
+data Tuple33# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1 #)
+type Tuple34# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34])
+data Tuple34# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1 #)
+type Tuple35# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35])
+data Tuple35# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1 #)
+type Tuple36# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36])
+data Tuple36# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1 #)
+type Tuple37# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37])
+data Tuple37# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1 #)
+type Tuple38# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38])
+data Tuple38# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1 #)
+type Tuple39# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39])
+data Tuple39# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1 #)
+type Tuple40# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40])
+data Tuple40# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1 #)
+type Tuple41# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41])
+data Tuple41# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1 #)
+type Tuple42# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42])
+data Tuple42# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1 #)
+type Tuple43# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43])
+data Tuple43# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1 #)
+type Tuple44# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44])
+data Tuple44# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1 #)
+type Tuple45# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45])
+data Tuple45# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1 #)
+type Tuple46# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46])
+data Tuple46# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1 #)
+type Tuple47# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47])
+data Tuple47# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1 #)
+type Tuple48# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48])
+data Tuple48# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1 #)
+type Tuple49# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49])
+data Tuple49# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1 #)
+type Tuple50# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50])
+data Tuple50# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1 #)
+type Tuple51# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51])
+data Tuple51# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1 #)
+type Tuple52# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52])
+data Tuple52# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1 #)
+type Tuple53# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53])
+data Tuple53# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2 #)
+type Tuple54# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54])
+data Tuple54# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2 #)
+type Tuple55# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55])
+data Tuple55# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2 #)
+type Tuple56# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56])
+data Tuple56# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2 #)
+type Tuple57# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57])
+data Tuple57# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2 #)
+type Tuple58# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58])
+data Tuple58# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2 #)
+type Tuple59# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59])
+data Tuple59# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2 #)
+type Tuple60# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60])
+data Tuple60# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2 #)
+type Tuple61# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61])
+data Tuple61# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2 #)
+type Tuple62# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62])
+data Tuple62# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2 #)
+type Tuple63# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63])
+data Tuple63# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2 #)
+type Tuple64# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 ->
+ TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 ->
+ TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 ->
+ TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 ->
+ TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 ->
+ TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 ->
+ TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 -> TYPE r64 ->
+ TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22,
+ r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45,
+ r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64])
+data Tuple64# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1
+ r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2 =
+ (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,
+ u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2 #)
+
+{-
+Note [Unboxed sum with arity 64]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+While tuples are defined up to arity 64, sums can maximally have 63 alternatives.
+This is due to the Unique layout for unboxed sums, which allots only six bits
+for encoding the alternative.
+-}
+
+type Sum2# :: TYPE r1 -> TYPE r2 -> TYPE (SumRep [r1, r2])
+data Sum2# a b =
+ (# a | #)
+ | (# | b #)
+
+type Sum3# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE (SumRep [r1, r2, r3])
+data Sum3# a b c =
+ (# a | | #)
+ | (# | b | #)
+ | (# | | c #)
+
+type Sum4# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE (SumRep [r1, r2, r3, r4])
+data Sum4# a b c d =
+ (# a | | | #)
+ | (# | b | | #)
+ | (# | | c | #)
+ | (# | | | d #)
+
+type Sum5# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE (SumRep [r1, r2, r3, r4, r5])
+data Sum5# a b c d e =
+ (# a | | | | #)
+ | (# | b | | | #)
+ | (# | | c | | #)
+ | (# | | | d | #)
+ | (# | | | | e #)
+
+type Sum6# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6])
+data Sum6# a b c d e f =
+ (# a | | | | | #)
+ | (# | b | | | | #)
+ | (# | | c | | | #)
+ | (# | | | d | | #)
+ | (# | | | | e | #)
+ | (# | | | | | f #)
+
+type Sum7# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7])
+data Sum7# a b c d e f g =
+ (# a | | | | | | #)
+ | (# | b | | | | | #)
+ | (# | | c | | | | #)
+ | (# | | | d | | | #)
+ | (# | | | | e | | #)
+ | (# | | | | | f | #)
+ | (# | | | | | | g #)
+
+type Sum8# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8])
+data Sum8# a b c d e f g h =
+ (# a | | | | | | | #)
+ | (# | b | | | | | | #)
+ | (# | | c | | | | | #)
+ | (# | | | d | | | | #)
+ | (# | | | | e | | | #)
+ | (# | | | | | f | | #)
+ | (# | | | | | | g | #)
+ | (# | | | | | | | h #)
+
+type Sum9# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9])
+data Sum9# a b c d e f g h i =
+ (# a | | | | | | | | #)
+ | (# | b | | | | | | | #)
+ | (# | | c | | | | | | #)
+ | (# | | | d | | | | | #)
+ | (# | | | | e | | | | #)
+ | (# | | | | | f | | | #)
+ | (# | | | | | | g | | #)
+ | (# | | | | | | | h | #)
+ | (# | | | | | | | | i #)
+
+type Sum10# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10])
+data Sum10# a b c d e f g h i j =
+ (# a | | | | | | | | | #)
+ | (# | b | | | | | | | | #)
+ | (# | | c | | | | | | | #)
+ | (# | | | d | | | | | | #)
+ | (# | | | | e | | | | | #)
+ | (# | | | | | f | | | | #)
+ | (# | | | | | | g | | | #)
+ | (# | | | | | | | h | | #)
+ | (# | | | | | | | | i | #)
+ | (# | | | | | | | | | j #)
+
+type Sum11# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11])
+data Sum11# a b c d e f g h i j k =
+ (# a | | | | | | | | | | #)
+ | (# | b | | | | | | | | | #)
+ | (# | | c | | | | | | | | #)
+ | (# | | | d | | | | | | | #)
+ | (# | | | | e | | | | | | #)
+ | (# | | | | | f | | | | | #)
+ | (# | | | | | | g | | | | #)
+ | (# | | | | | | | h | | | #)
+ | (# | | | | | | | | i | | #)
+ | (# | | | | | | | | | j | #)
+ | (# | | | | | | | | | | k #)
+
+type Sum12# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12])
+data Sum12# a b c d e f g h i j k l =
+ (# a | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | #)
+ | (# | | | d | | | | | | | | #)
+ | (# | | | | e | | | | | | | #)
+ | (# | | | | | f | | | | | | #)
+ | (# | | | | | | g | | | | | #)
+ | (# | | | | | | | h | | | | #)
+ | (# | | | | | | | | i | | | #)
+ | (# | | | | | | | | | j | | #)
+ | (# | | | | | | | | | | k | #)
+ | (# | | | | | | | | | | | l #)
+
+type Sum13# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13])
+data Sum13# a b c d e f g h i j k l m =
+ (# a | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | #)
+ | (# | | | | | f | | | | | | | #)
+ | (# | | | | | | g | | | | | | #)
+ | (# | | | | | | | h | | | | | #)
+ | (# | | | | | | | | i | | | | #)
+ | (# | | | | | | | | | j | | | #)
+ | (# | | | | | | | | | | k | | #)
+ | (# | | | | | | | | | | | l | #)
+ | (# | | | | | | | | | | | | m #)
+
+type Sum14# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14])
+data Sum14# a b c d e f g h i j k l m n =
+ (# a | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | #)
+ | (# | | | | | | | h | | | | | | #)
+ | (# | | | | | | | | i | | | | | #)
+ | (# | | | | | | | | | j | | | | #)
+ | (# | | | | | | | | | | k | | | #)
+ | (# | | | | | | | | | | | l | | #)
+ | (# | | | | | | | | | | | | m | #)
+ | (# | | | | | | | | | | | | | n #)
+
+type Sum15# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15])
+data Sum15# a b c d e f g h i j k l m n o =
+ (# a | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | #)
+ | (# | | | | | | | | | j | | | | | #)
+ | (# | | | | | | | | | | k | | | | #)
+ | (# | | | | | | | | | | | l | | | #)
+ | (# | | | | | | | | | | | | m | | #)
+ | (# | | | | | | | | | | | | | n | #)
+ | (# | | | | | | | | | | | | | | o #)
+
+type Sum16# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16])
+data Sum16# a b c d e f g h i j k l m n o p =
+ (# a | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | #)
+ | (# | | | | | | | | | | | l | | | | #)
+ | (# | | | | | | | | | | | | m | | | #)
+ | (# | | | | | | | | | | | | | n | | #)
+ | (# | | | | | | | | | | | | | | o | #)
+ | (# | | | | | | | | | | | | | | | p #)
+
+type Sum17# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17])
+data Sum17# a b c d e f g h i j k l m n o p q =
+ (# a | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | #)
+ | (# | | | | | | | | | | | | | n | | | #)
+ | (# | | | | | | | | | | | | | | o | | #)
+ | (# | | | | | | | | | | | | | | | p | #)
+ | (# | | | | | | | | | | | | | | | | q #)
+
+type Sum18# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18])
+data Sum18# a b c d e f g h i j k l m n o p q r =
+ (# a | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | #)
+ | (# | | | | | | | | | | | | | | | p | | #)
+ | (# | | | | | | | | | | | | | | | | q | #)
+ | (# | | | | | | | | | | | | | | | | | r #)
+
+type Sum19# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19])
+data Sum19# a b c d e f g h i j k l m n o p q r s =
+ (# a | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | #)
+ | (# | | | | | | | | | | | | | | | | | r | #)
+ | (# | | | | | | | | | | | | | | | | | | s #)
+
+type Sum20# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20])
+data Sum20# a b c d e f g h i j k l m n o p q r s t =
+ (# a | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | #)
+ | (# | | | | | | | | | | | | | | | | | | | t #)
+
+type Sum21# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21])
+data Sum21# a b c d e f g h i j k l m n o p q r s t u =
+ (# a | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u #)
+
+type Sum22# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22])
+data Sum22# a b c d e f g h i j k l m n o p q r s t u v =
+ (# a | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v #)
+
+type Sum23# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23])
+data Sum23# a b c d e f g h i j k l m n o p q r s t u v w =
+ (# a | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w #)
+
+type Sum24# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24])
+data Sum24# a b c d e f g h i j k l m n o p q r s t u v w x =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x #)
+
+type Sum25# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25])
+data Sum25# a b c d e f g h i j k l m n o p q r s t u v w x y =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y #)
+
+type Sum26# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26])
+data Sum26# a b c d e f g h i j k l m n o p q r s t u v w x y z =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z #)
+
+type Sum27# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27])
+data Sum27# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 #)
+
+type Sum28# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28])
+data Sum28# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 #)
+
+type Sum29# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29])
+data Sum29# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 #)
+
+type Sum30# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30])
+data Sum30# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 #)
+
+type Sum31# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31])
+data Sum31# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 #)
+
+type Sum32# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32])
+data Sum32# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 #)
+
+type Sum33# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33])
+data Sum33# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 #)
+
+type Sum34# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34])
+data Sum34# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 #)
+
+type Sum35# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35])
+data Sum35# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 #)
+
+type Sum36# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36])
+data Sum36# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 #)
+
+type Sum37# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37])
+data Sum37# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 #)
+
+type Sum38# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38])
+data Sum38# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 #)
+
+type Sum39# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39])
+data Sum39# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 #)
+
+type Sum40# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40])
+data Sum40# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 #)
+
+type Sum41# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41])
+data Sum41# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 #)
+
+type Sum42# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42])
+data Sum42# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 #)
+
+type Sum43# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43])
+data Sum43# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 #)
+
+type Sum44# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44])
+data Sum44# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 #)
+
+type Sum45# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45])
+data Sum45# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 #)
+
+type Sum46# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46])
+data Sum46# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 #)
+
+type Sum47# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47])
+data Sum47# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 #)
+
+type Sum48# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48])
+data Sum48# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 #)
+
+type Sum49# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49])
+data Sum49# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 #)
+
+type Sum50# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50])
+data Sum50# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 #)
+
+type Sum51# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51])
+data Sum51# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 #)
+
+type Sum52# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52])
+data Sum52# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 #)
+
+type Sum53# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53])
+data Sum53# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 #)
+
+type Sum54# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54])
+data Sum54# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 #)
+
+type Sum55# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55])
+data Sum55# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 #)
+
+type Sum56# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56])
+data Sum56# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 #)
+
+type Sum57# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57])
+data Sum57# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 #)
+
+type Sum58# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58])
+data Sum58# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 #)
+
+type Sum59# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59])
+data Sum59# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 #)
+
+type Sum60# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60])
+data Sum60# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 #)
+
+type Sum61# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61])
+data Sum61# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 #)
+
+type Sum62# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62])
+data Sum62# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j2 #)
+
+type Sum63# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63])
+data Sum63# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 =
+ (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 | | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j2 | #)
+ | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k2 #)
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,2 +1,88 @@
+
+-- We need to do some ugly hacks here because of GHC magic
+
+module Main (main) where
+
+import Control.Monad
+import Data.List
+import Data.Maybe
+import Distribution.PackageDescription
import Distribution.Simple
-main = defaultMain
+import Distribution.Simple.LocalBuildInfo
+import Distribution.Simple.Program
+import Distribution.Simple.Utils
+import Distribution.Text
+import System.Cmd
+import System.FilePath
+import System.Exit
+import System.Directory
+
+main :: IO ()
+main = do let hooks = simpleUserHooks {
+ regHook = addPrimModule
+ $ regHook simpleUserHooks,
+ buildHook = build_primitive_sources
+ $ buildHook simpleUserHooks,
+ haddockHook = addPrimModuleForHaddock
+ $ build_primitive_sources
+ $ haddockHook simpleUserHooks }
+ defaultMainWithHooks hooks
+
+type Hook a = PackageDescription -> LocalBuildInfo -> UserHooks -> a -> IO ()
+
+addPrimModule :: Hook a -> Hook a
+addPrimModule f pd lbi uhs x =
+ do let -- I'm not sure which one of these we actually need to change.
+ -- It seems bad that there are two.
+ pd' = addPrimModuleToPD pd
+ lpd = addPrimModuleToPD (localPkgDescr lbi)
+ lbi' = lbi { localPkgDescr = lpd }
+ f pd' lbi' uhs x
+
+addPrimModuleForHaddock :: Hook a -> Hook a
+addPrimModuleForHaddock f pd lbi uhs x =
+ do let pc = withPrograms lbi
+ pc' = userSpecifyArgs "haddock" ["GHC/Prim.hs"] pc
+ lbi' = lbi { withPrograms = pc' }
+ f pd lbi' uhs x
+
+addPrimModuleToPD :: PackageDescription -> PackageDescription
+addPrimModuleToPD pd =
+ case library pd of
+ Just lib ->
+ let ems = fromJust (simpleParse "GHC.Prim") : exposedModules lib
+ lib' = lib { exposedModules = ems }
+ in pd { library = Just lib' }
+ Nothing ->
+ error "Expected a library, but none found"
+
+build_primitive_sources :: Hook a -> Hook a
+build_primitive_sources f pd lbi uhs x
+ = do when (compilerFlavor (compiler lbi) == GHC) $ do
+ let genprimopcode = joinPath ["..", "..", "utils",
+ "genprimopcode", "genprimopcode"]
+ primops = joinPath ["..", "..", "compiler", "prelude",
+ "primops.txt"]
+ primhs = joinPath ["GHC", "Prim.hs"]
+ primopwrappers = joinPath ["GHC", "PrimopWrappers.hs"]
+ primhs_tmp = addExtension primhs "tmp"
+ primopwrappers_tmp = addExtension primopwrappers "tmp"
+ maybeExit $ system (genprimopcode ++ " --make-haskell-source < "
+ ++ primops ++ " > " ++ primhs_tmp)
+ maybeUpdateFile primhs_tmp primhs
+ maybeExit $ system (genprimopcode ++ " --make-haskell-wrappers < "
+ ++ primops ++ " > " ++ primopwrappers_tmp)
+ maybeUpdateFile primopwrappers_tmp primopwrappers
+ f pd lbi uhs x
+
+-- Replace a file only if the new version is different from the old.
+-- This prevents make from doing unnecessary work after we run 'setup makefile'
+maybeUpdateFile :: FilePath -> FilePath -> IO ()
+maybeUpdateFile source target = do
+ r <- rawSystem "cmp" ["-s" {-quiet-}, source, target]
+ case r of
+ ExitSuccess -> removeFile source
+ ExitFailure _ -> do exists <- doesFileExist target
+ when exists $ removeFile target
+ renameFile source target
+
diff --git a/cbits/atomic.c b/cbits/atomic.c
--- a/cbits/atomic.c
+++ b/cbits/atomic.c
@@ -1,3 +1,4 @@
+#if !defined(arm_HOST_ARCH)
#include "Rts.h"
// Fallbacks for atomic primops on byte arrays. The builtins used
@@ -11,103 +12,133 @@
// FetchAddByteArrayOp_Int
-extern StgWord hs_atomic_add8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_add8(StgWord x, StgWord val);
StgWord
-hs_atomic_add8(volatile StgWord8 *x, StgWord val)
+hs_atomic_add8(StgWord x, StgWord val)
{
- return __sync_fetch_and_add(x, (StgWord8) val);
+ return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);
}
-extern StgWord hs_atomic_add16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_add16(StgWord x, StgWord val);
StgWord
-hs_atomic_add16(volatile StgWord16 *x, StgWord val)
+hs_atomic_add16(StgWord x, StgWord val)
{
- return __sync_fetch_and_add(x, (StgWord16) val);
+ return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);
}
-extern StgWord hs_atomic_add32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_add32(StgWord x, StgWord val);
StgWord
-hs_atomic_add32(volatile StgWord32 *x, StgWord val)
+hs_atomic_add32(StgWord x, StgWord val)
{
- return __sync_fetch_and_add(x, (StgWord32) val);
+ return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_add64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_add64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_add64(StgWord x, StgWord64 val)
{
- return __sync_fetch_and_add(x, val);
+ return __sync_fetch_and_add((volatile StgWord64 *) x, val);
}
-#endif
// FetchSubByteArrayOp_Int
-extern StgWord hs_atomic_sub8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_sub8(StgWord x, StgWord val);
StgWord
-hs_atomic_sub8(volatile StgWord8 *x, StgWord val)
+hs_atomic_sub8(StgWord x, StgWord val)
{
- return __sync_fetch_and_sub(x, (StgWord8) val);
+ return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);
}
-extern StgWord hs_atomic_sub16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_sub16(StgWord x, StgWord val);
StgWord
-hs_atomic_sub16(volatile StgWord16 *x, StgWord val)
+hs_atomic_sub16(StgWord x, StgWord val)
{
- return __sync_fetch_and_sub(x, (StgWord16) val);
+ return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);
}
-extern StgWord hs_atomic_sub32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_sub32(StgWord x, StgWord val);
StgWord
-hs_atomic_sub32(volatile StgWord32 *x, StgWord val)
+hs_atomic_sub32(StgWord x, StgWord val)
{
- return __sync_fetch_and_sub(x, (StgWord32) val);
+ return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_sub64(StgWord x, StgWord64 val)
{
- return __sync_fetch_and_sub(x, val);
+ return __sync_fetch_and_sub((volatile StgWord64 *) x, val);
}
-#endif
// FetchAndByteArrayOp_Int
-extern StgWord hs_atomic_and8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_and8(StgWord x, StgWord val);
StgWord
-hs_atomic_and8(volatile StgWord8 *x, StgWord val)
+hs_atomic_and8(StgWord x, StgWord val)
{
- return __sync_fetch_and_and(x, (StgWord8) val);
+ return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);
}
-extern StgWord hs_atomic_and16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_and16(StgWord x, StgWord val);
StgWord
-hs_atomic_and16(volatile StgWord16 *x, StgWord val)
+hs_atomic_and16(StgWord x, StgWord val)
{
- return __sync_fetch_and_and(x, (StgWord16) val);
+ return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);
}
-extern StgWord hs_atomic_and32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_and32(StgWord x, StgWord val);
StgWord
-hs_atomic_and32(volatile StgWord32 *x, StgWord val)
+hs_atomic_and32(StgWord x, StgWord val)
{
- return __sync_fetch_and_and(x, (StgWord32) val);
+ return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_and64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_and64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_and64(StgWord x, StgWord64 val)
{
- return __sync_fetch_and_and(x, val);
+ return __sync_fetch_and_and((volatile StgWord64 *) x, val);
}
-#endif
// FetchNandByteArrayOp_Int
-// Workaround for http://llvm.org/bugs/show_bug.cgi?id=8842
+// Note [__sync_fetch_and_nand usage]
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The __sync_fetch_and_nand builtin is a bit of a disaster. It was introduced
+// in GCC long ago with silly semantics. Specifically:
+//
+// *ptr = ~(tmp & value)
+//
+// Clang introduced the builtin with the same semantics.
+//
+// In GCC 4.4 the operation's semantics were rightly changed to,
+//
+// *ptr = ~tmp & value
+//
+// and the -Wsync-nand warning was added warning users of the operation about
+// the change.
+//
+// Clang took this change as a reason to remove support for the
+// builtin in 2010. Then, in 2014 Clang re-added support with the new
+// semantics. However, the warning flag was given a different name
+// (-Wsync-fetch-and-nand-semantics-changed) for added fun.
+//
+// Consequently, we are left with a bit of a mess: GHC requires GCC >4.4
+// (enforced by the FP_GCC_VERSION autoconf check), so we thankfully don't need
+// to support the operation's older broken semantics. However, we need to take
+// care to explicitly disable -Wsync-nand wherever possible, lest the build
+// fails with -Werror. Furthermore, we need to emulate the operation when
+// building with some Clang versions (shipped by some Mac OS X releases) which
+// lack support for the builtin.
+//
+// In the words of Bob Dylan: everything is broken.
+//
+// See also:
+//
+// * https://bugs.llvm.org/show_bug.cgi?id=8842
+// * https://gitlab.haskell.org/ghc/ghc/issues/9678
+//
+
#define CAS_NAND(x, val) \
{ \
__typeof__ (*(x)) tmp = *(x); \
@@ -117,204 +148,268 @@
return tmp; \
}
-extern StgWord hs_atomic_nand8(volatile StgWord8 *x, StgWord val);
+// N.B. __has_builtin is only provided by clang
+#if !defined(__has_builtin)
+#define __has_builtin(x) 0
+#endif
+
+#if defined(__clang__) && !__has_builtin(__sync_fetch_and_nand)
+#define USE_SYNC_FETCH_AND_NAND 0
+#else
+#define USE_SYNC_FETCH_AND_NAND 1
+#endif
+
+// Otherwise this fails with -Werror
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Wsync-fetch-and-nand-semantics-changed"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wsync-nand"
+#endif
+
+extern StgWord hs_atomic_nand8(StgWord x, StgWord val);
StgWord
-hs_atomic_nand8(volatile StgWord8 *x, StgWord val)
+hs_atomic_nand8(StgWord x, StgWord val)
{
-#ifdef __clang__
- CAS_NAND(x, (StgWord8) val)
+#if USE_SYNC_FETCH_AND_NAND
+ return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);
#else
- return __sync_fetch_and_nand(x, (StgWord8) val);
+ CAS_NAND((volatile StgWord8 *) x, (StgWord8) val)
#endif
}
-extern StgWord hs_atomic_nand16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_nand16(StgWord x, StgWord val);
StgWord
-hs_atomic_nand16(volatile StgWord16 *x, StgWord val)
+hs_atomic_nand16(StgWord x, StgWord val)
{
-#ifdef __clang__
- CAS_NAND(x, (StgWord16) val);
+#if USE_SYNC_FETCH_AND_NAND
+ return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);
#else
- return __sync_fetch_and_nand(x, (StgWord16) val);
+ CAS_NAND((volatile StgWord16 *) x, (StgWord16) val);
#endif
}
-extern StgWord hs_atomic_nand32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_nand32(StgWord x, StgWord val);
StgWord
-hs_atomic_nand32(volatile StgWord32 *x, StgWord val)
+hs_atomic_nand32(StgWord x, StgWord val)
{
-#ifdef __clang__
- CAS_NAND(x, (StgWord32) val);
+#if USE_SYNC_FETCH_AND_NAND
+ return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);
#else
- return __sync_fetch_and_nand(x, (StgWord32) val);
+ CAS_NAND((volatile StgWord32 *) x, (StgWord32) val);
#endif
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_nand64(StgWord x, StgWord64 val)
{
-#ifdef __clang__
- CAS_NAND(x, val);
+#if USE_SYNC_FETCH_AND_NAND
+ return __sync_fetch_and_nand((volatile StgWord64 *) x, val);
#else
- return __sync_fetch_and_nand(x, val);
+ CAS_NAND((volatile StgWord64 *) x, val);
#endif
}
-#endif
+#pragma GCC diagnostic pop
+
// FetchOrByteArrayOp_Int
-extern StgWord hs_atomic_or8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_or8(StgWord x, StgWord val);
StgWord
-hs_atomic_or8(volatile StgWord8 *x, StgWord val)
+hs_atomic_or8(StgWord x, StgWord val)
{
- return __sync_fetch_and_or(x, (StgWord8) val);
+ return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);
}
-extern StgWord hs_atomic_or16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_or16(StgWord x, StgWord val);
StgWord
-hs_atomic_or16(volatile StgWord16 *x, StgWord val)
+hs_atomic_or16(StgWord x, StgWord val)
{
- return __sync_fetch_and_or(x, (StgWord16) val);
+ return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);
}
-extern StgWord hs_atomic_or32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_or32(StgWord x, StgWord val);
StgWord
-hs_atomic_or32(volatile StgWord32 *x, StgWord val)
+hs_atomic_or32(StgWord x, StgWord val)
{
- return __sync_fetch_and_or(x, (StgWord32) val);
+ return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_or64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_or64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_or64(StgWord x, StgWord64 val)
{
- return __sync_fetch_and_or(x, val);
+ return __sync_fetch_and_or((volatile StgWord64 *) x, val);
}
-#endif
// FetchXorByteArrayOp_Int
-extern StgWord hs_atomic_xor8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_xor8(StgWord x, StgWord val);
StgWord
-hs_atomic_xor8(volatile StgWord8 *x, StgWord val)
+hs_atomic_xor8(StgWord x, StgWord val)
{
- return __sync_fetch_and_xor(x, (StgWord8) val);
+ return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);
}
-extern StgWord hs_atomic_xor16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_xor16(StgWord x, StgWord val);
StgWord
-hs_atomic_xor16(volatile StgWord16 *x, StgWord val)
+hs_atomic_xor16(StgWord x, StgWord val)
{
- return __sync_fetch_and_xor(x, (StgWord16) val);
+ return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);
}
-extern StgWord hs_atomic_xor32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_xor32(StgWord x, StgWord val);
StgWord
-hs_atomic_xor32(volatile StgWord32 *x, StgWord val)
+hs_atomic_xor32(StgWord x, StgWord val)
{
- return __sync_fetch_and_xor(x, (StgWord32) val);
+ return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val);
StgWord64
-hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_xor64(StgWord x, StgWord64 val)
{
- return __sync_fetch_and_xor(x, val);
+ return __sync_fetch_and_xor((volatile StgWord64 *) x, val);
}
-#endif
// CasByteArrayOp_Int
-extern StgWord hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new);
StgWord
-hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new)
+hs_cmpxchg8(StgWord x, StgWord old, StgWord new)
{
- return __sync_val_compare_and_swap(x, (StgWord8) old, (StgWord8) new);
+ StgWord8 expected = (StgWord8) old;
+ __atomic_compare_exchange_n((StgWord8 *) x, &expected, (StgWord8) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+ return expected;
}
-extern StgWord hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new);
StgWord
-hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new)
+hs_cmpxchg16(StgWord x, StgWord old, StgWord new)
{
- return __sync_val_compare_and_swap(x, (StgWord16) old, (StgWord16) new);
+ StgWord16 expected = (StgWord16) old;
+ __atomic_compare_exchange_n((StgWord16 *) x, &expected, (StgWord16) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+ return expected;
}
-extern StgWord hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new);
StgWord
-hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new)
+hs_cmpxchg32(StgWord x, StgWord old, StgWord new)
{
- return __sync_val_compare_and_swap(x, (StgWord32) old, (StgWord32) new);
+ StgWord32 expected = (StgWord32) old;
+ __atomic_compare_exchange_n((StgWord32 *) x, &expected, (StgWord32) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+ return expected;
}
-#if WORD_SIZE_IN_BITS == 64
-extern StgWord hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new);
+extern StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new);
+StgWord64
+hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
+{
+ StgWord64 expected = (StgWord64) old;
+ __atomic_compare_exchange_n((StgWord64 *) x, &expected, (StgWord64) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+ return expected;
+}
+
+// Atomic exchange operations
+
+extern StgWord hs_xchg8(StgWord x, StgWord val);
StgWord
-hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new)
+hs_xchg8(StgWord x, StgWord val)
{
- return __sync_val_compare_and_swap(x, old, new);
+ return (StgWord) __atomic_exchange_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
}
-#endif
+extern StgWord hs_xchg16(StgWord x, StgWord val);
+StgWord
+hs_xchg16(StgWord x, StgWord val)
+{
+ return (StgWord) __atomic_exchange_n((StgWord16 *)x, (StgWord16) val, __ATOMIC_SEQ_CST);
+}
+
+extern StgWord hs_xchg32(StgWord x, StgWord val);
+StgWord
+hs_xchg32(StgWord x, StgWord val)
+{
+ return (StgWord) __atomic_exchange_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
+}
+
+//GCC provides this even on 32bit, but StgWord is still 32 bits.
+extern StgWord64 hs_xchg64(StgWord x, StgWord64 val);
+StgWord64
+hs_xchg64(StgWord x, StgWord64 val)
+{
+ return (StgWord64) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);
+}
+
// AtomicReadByteArrayOp_Int
+// Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp)
+// __ATOMIC_SEQ_CST: Full barrier in both directions (hoisting and sinking
+// of code) and synchronizes with acquire loads and release stores in
+// all threads.
+//
+// When we lack C11 atomics support we emulate these using the old GCC __sync
+// primitives which the GCC documentation claims "usually" implies a full
+// barrier.
-extern StgWord hs_atomicread8(volatile StgWord8 *x);
+extern StgWord hs_atomicread8(StgWord x);
StgWord
-hs_atomicread8(volatile StgWord8 *x)
+hs_atomicread8(StgWord x)
{
- return *x;
+ return __atomic_load_n((StgWord8 *) x, __ATOMIC_SEQ_CST);
}
-extern StgWord hs_atomicread16(volatile StgWord16 *x);
+extern StgWord hs_atomicread16(StgWord x);
StgWord
-hs_atomicread16(volatile StgWord16 *x)
+hs_atomicread16(StgWord x)
{
- return *x;
+ return __atomic_load_n((StgWord16 *) x, __ATOMIC_SEQ_CST);
}
-extern StgWord hs_atomicread32(volatile StgWord32 *x);
+extern StgWord hs_atomicread32(StgWord x);
StgWord
-hs_atomicread32(volatile StgWord32 *x)
+hs_atomicread32(StgWord x)
{
- return *x;
+ return __atomic_load_n((StgWord32 *) x, __ATOMIC_SEQ_CST);
}
-extern StgWord64 hs_atomicread64(volatile StgWord64 *x);
+extern StgWord64 hs_atomicread64(StgWord x);
StgWord64
-hs_atomicread64(volatile StgWord64 *x)
+hs_atomicread64(StgWord x)
{
- return *x;
+ return __atomic_load_n((StgWord64 *) x, __ATOMIC_SEQ_CST);
}
// AtomicWriteByteArrayOp_Int
+// Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp)
+// __ATOMIC_SEQ_CST: Full barrier (see hs_atomicread8 above).
-extern void hs_atomicwrite8(volatile StgWord8 *x, StgWord val);
+extern void hs_atomicwrite8(StgWord x, StgWord val);
void
-hs_atomicwrite8(volatile StgWord8 *x, StgWord val)
+hs_atomicwrite8(StgWord x, StgWord val)
{
- *x = (StgWord8) val;
+ __atomic_store_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
}
-extern void hs_atomicwrite16(volatile StgWord16 *x, StgWord val);
+extern void hs_atomicwrite16(StgWord x, StgWord val);
void
-hs_atomicwrite16(volatile StgWord16 *x, StgWord val)
+hs_atomicwrite16(StgWord x, StgWord val)
{
- *x = (StgWord16) val;
+ __atomic_store_n((StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
}
-extern void hs_atomicwrite32(volatile StgWord32 *x, StgWord val);
+extern void hs_atomicwrite32(StgWord x, StgWord val);
void
-hs_atomicwrite32(volatile StgWord32 *x, StgWord val)
+hs_atomicwrite32(StgWord x, StgWord val)
{
- *x = (StgWord32) val;
+ __atomic_store_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
}
-extern void hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val);
+extern void hs_atomicwrite64(StgWord x, StgWord64 val);
void
-hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val)
+hs_atomicwrite64(StgWord x, StgWord64 val)
{
- *x = (StgWord64) val;
+ __atomic_store_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);
}
+
+#endif
diff --git a/cbits/bitrev.c b/cbits/bitrev.c
new file mode 100644
--- /dev/null
+++ b/cbits/bitrev.c
@@ -0,0 +1,80 @@
+#include "Rts.h"
+
+/*
+Note [Bit reversal primop]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+There are two main ways of reversing the bit order of a word: bit twiddling
+and using a lookup table.
+See [this excellent](https://stackoverflow.com/questions/746171/most-efficient-algorithm-for-bit-reversal-from-msb-lsb-to-lsb-msb-in-c this)
+Stack Overflow answer about bit order reversal for (much) more detail.
+(Link valid as of March 2019.)
+
+To summarize,
+
+ * the lookup table is faster, but much more memory-heavy e.g.
+ doing it for 64-bit words can take 64KB if only 16-bits are reversed at
+ a time.
+ * working directly with bits is slower (roughly on the same order of
+ magnitude as the previous alternative), but uses much less memory as
+ bit-wise operators aren't space-onerous.
+
+The code below uses the latter option. If in the future the performance of this
+primop must be improved, the information provided in this comment should be
+useful in making the decision of which changes to make.
+
+For more information on how the below bit-twiddling functions came to be, see
+[this](http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel)
+page.
+*/
+
+extern StgWord hs_bitrev8(StgWord x);
+StgWord
+hs_bitrev8(StgWord x)
+{
+ x = ((x >> 1) & 0x55) | ((x & 0x55) << 1 );
+ x = ((x >> 2) & 0x33) | ((x & 0x33) << 2 );
+ x = ((x >> 4) & 0x0F) | ((x & 0x0F) << 4 );
+ return x;
+}
+
+extern StgWord16 hs_bitrev16(StgWord16 x);
+StgWord16
+hs_bitrev16(StgWord16 x)
+{
+ x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1 );
+ x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2 );
+ x = ((x >> 4) & 0x0F0F) | ((x & 0x0F0F) << 4 );
+ x = ((x >> 8) & 0x00FF) | ((x & 0x00FF) << 8 );
+ return x;
+}
+
+extern StgWord32 hs_bitrev32(StgWord32 x);
+StgWord32
+hs_bitrev32(StgWord32 x)
+{
+ x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1 );
+ x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2 );
+ x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4 );
+ x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8 );
+ x = ( x >> 16 ) | ( x << 16 );
+ return x;
+}
+
+extern StgWord64 hs_bitrev64(StgWord64 x);
+StgWord64
+hs_bitrev64(StgWord64 x)
+{
+ // swap odd and even bits
+ x = ((x >> 1) & 0x5555555555555555) | ((x & 0x5555555555555555) << 1 );
+ // swap consecutive pairs of bits
+ x = ((x >> 2) & 0x3333333333333333) | ((x & 0x3333333333333333) << 2 );
+ // swap consecutive pairs of nibbles (a nibble is 4 bits)
+ x = ((x >> 4) & 0x0F0F0F0F0F0F0F0F) | ((x & 0x0F0F0F0F0F0F0F0F) << 4 );
+ // swap consecutive pairs of bytes
+ x = ((x >> 8) & 0x00FF00FF00FF00FF) | ((x & 0x00FF00FF00FF00FF) << 8 );
+ // swap consecutive pairs of 16-bit words
+ x = ((x >> 16) & 0x0000FFFF0000FFFF) | ((x & 0x0000FFFF0000FFFF) << 16);
+ // swap 32-bit long pairs
+ x = ( x >> 32 ) | ( x << 32 );
+ return x;
+}
diff --git a/cbits/ctz.c b/cbits/ctz.c
--- a/cbits/ctz.c
+++ b/cbits/ctz.c
@@ -31,12 +31,12 @@
StgWord
hs_ctz64(StgWord64 x)
{
-#if defined(__GNUC__) && defined(i386_HOST_ARCH)
- /* On Linux/i386, the 64bit `__builtin_ctzll()` instrinsic doesn't
+#if defined(__GNUC__) && (defined(i386_HOST_ARCH) || defined(powerpc_HOST_ARCH))
+ /* On Linux/i386, the 64bit `__builtin_ctzll()` intrinsic doesn't
get inlined by GCC but rather a short `__ctzdi2` runtime function
is inserted when needed into compiled object files.
- This workaround forces GCC on 32bit x86 to to express `hs_ctz64` in
+ This workaround forces GCC on 32bit x86 to express `hs_ctz64` in
terms of the 32bit `__builtin_ctz()` (this is no loss, as there's no
64bit BSF instruction on i686 anyway) and thus avoid the problematic
out-of-line runtime function.
diff --git a/cbits/longlong.c b/cbits/longlong.c
--- a/cbits/longlong.c
+++ b/cbits/longlong.c
@@ -32,31 +32,32 @@
/* Relational operators */
+HsInt hs_eq64 (HsWord64 a, HsWord64 b) {return a == b;}
+HsInt hs_ne64 (HsWord64 a, HsWord64 b) {return a != b;}
+
HsInt hs_gtWord64 (HsWord64 a, HsWord64 b) {return a > b;}
HsInt hs_geWord64 (HsWord64 a, HsWord64 b) {return a >= b;}
-HsInt hs_eqWord64 (HsWord64 a, HsWord64 b) {return a == b;}
-HsInt hs_neWord64 (HsWord64 a, HsWord64 b) {return a != b;}
HsInt hs_ltWord64 (HsWord64 a, HsWord64 b) {return a < b;}
HsInt hs_leWord64 (HsWord64 a, HsWord64 b) {return a <= b;}
HsInt hs_gtInt64 (HsInt64 a, HsInt64 b) {return a > b;}
HsInt hs_geInt64 (HsInt64 a, HsInt64 b) {return a >= b;}
-HsInt hs_eqInt64 (HsInt64 a, HsInt64 b) {return a == b;}
-HsInt hs_neInt64 (HsInt64 a, HsInt64 b) {return a != b;}
HsInt hs_ltInt64 (HsInt64 a, HsInt64 b) {return a < b;}
HsInt hs_leInt64 (HsInt64 a, HsInt64 b) {return a <= b;}
/* Arithmetic operators */
+HsInt64 hs_neg64 (HsInt64 a) {return - a;}
+
+HsWord64 hs_add64 (HsWord64 a, HsWord64 b) {return a + b;}
+HsWord64 hs_sub64 (HsWord64 a, HsWord64 b) {return a - b;}
+HsWord64 hs_mul64 (HsWord64 a, HsWord64 b) {return a * b;}
+
HsWord64 hs_remWord64 (HsWord64 a, HsWord64 b) {return a % b;}
HsWord64 hs_quotWord64 (HsWord64 a, HsWord64 b) {return a / b;}
HsInt64 hs_remInt64 (HsInt64 a, HsInt64 b) {return a % b;}
HsInt64 hs_quotInt64 (HsInt64 a, HsInt64 b) {return a / b;}
-HsInt64 hs_negateInt64 (HsInt64 a) {return -a;}
-HsInt64 hs_plusInt64 (HsInt64 a, HsInt64 b) {return a + b;}
-HsInt64 hs_minusInt64 (HsInt64 a, HsInt64 b) {return a - b;}
-HsInt64 hs_timesInt64 (HsInt64 a, HsInt64 b) {return a * b;}
/* Logical operators: */
@@ -71,19 +72,14 @@
the behaviour you'll get from using these primops depends
on the whatever your C compiler is doing. ToDo: fix. -- sof 8/98
*/
-HsInt64 hs_uncheckedIShiftL64 (HsInt64 a, HsInt b) {return a << b;}
HsInt64 hs_uncheckedIShiftRA64 (HsInt64 a, HsInt b) {return a >> b;}
-HsInt64 hs_uncheckedIShiftRL64 (HsInt64 a, HsInt b)
- {return (HsInt64) ((HsWord64) a >> b);}
/* Casting between longs and longer longs.
*/
HsInt64 hs_intToInt64 (HsInt i) {return (HsInt64) i;}
HsInt hs_int64ToInt (HsInt64 i) {return (HsInt) i;}
-HsWord64 hs_int64ToWord64 (HsInt64 i) {return (HsWord64) i;}
HsWord64 hs_wordToWord64 (HsWord w) {return (HsWord64) w;}
HsWord hs_word64ToWord (HsWord64 w) {return (HsWord) w;}
-HsInt64 hs_word64ToInt64 (HsWord64 w) {return (HsInt64) w;}
#endif /* SUPPORT_LONG_LONGS */
diff --git a/cbits/mulIntMayOflo.c b/cbits/mulIntMayOflo.c
new file mode 100644
--- /dev/null
+++ b/cbits/mulIntMayOflo.c
@@ -0,0 +1,3 @@
+#include "Rts.h"
+
+W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); }
diff --git a/cbits/pdep.c b/cbits/pdep.c
new file mode 100644
--- /dev/null
+++ b/cbits/pdep.c
@@ -0,0 +1,43 @@
+#include "Rts.h"
+#include "MachDeps.h"
+
+StgWord64
+hs_pdep64(StgWord64 src, StgWord64 mask)
+{
+ uint64_t result = 0;
+
+ while (1) {
+ // Mask out all but the lowest bit
+ const uint64_t lowest = (-mask & mask);
+
+ if (lowest == 0) {
+ break;
+ }
+
+ const uint64_t lsb = (uint64_t)((int64_t)(src << 63) >> 63);
+
+ result |= lsb & lowest;
+ mask &= ~lowest;
+ src >>= 1;
+ }
+
+ return result;
+}
+
+StgWord
+hs_pdep32(StgWord src, StgWord mask)
+{
+ return hs_pdep64(src, mask);
+}
+
+StgWord
+hs_pdep16(StgWord src, StgWord mask)
+{
+ return hs_pdep64(src, mask);
+}
+
+StgWord
+hs_pdep8(StgWord src, StgWord mask)
+{
+ return hs_pdep64(src, mask);
+}
diff --git a/cbits/pext.c b/cbits/pext.c
new file mode 100644
--- /dev/null
+++ b/cbits/pext.c
@@ -0,0 +1,39 @@
+#include "Rts.h"
+#include "MachDeps.h"
+
+StgWord64
+hs_pext64(StgWord64 src, StgWord64 mask)
+{
+ uint64_t result = 0;
+ int offset = 0;
+
+ for (int bit = 0; bit != sizeof(uint64_t) * 8; ++bit) {
+ const uint64_t src_bit = (src >> bit) & 1;
+ const uint64_t mask_bit = (mask >> bit) & 1;
+
+ if (mask_bit) {
+ result |= (uint64_t)(src_bit) << offset;
+ ++offset;
+ }
+ }
+
+ return result;
+}
+
+StgWord
+hs_pext32(StgWord src, StgWord mask)
+{
+ return hs_pext64(src, mask);
+}
+
+StgWord
+hs_pext16(StgWord src, StgWord mask)
+{
+ return hs_pext64(src, mask);
+}
+
+StgWord
+hs_pext8(StgWord src, StgWord mask)
+{
+ return hs_pext64(src, mask);
+}
diff --git a/changelog.md b/changelog.md
new file mode 100644
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,626 @@
+## 0.13.0
+
+- Shipped with GHC 9.12.1
+
+- Add primops that allow users to distinguish weakly pinned byte arrays from unpinned ones.
+
+ isMutableByteArrayWeaklyPinned# :: MutableByteArray# s -> Int#
+ isByteArrayWeaklyPinned# :: ByteArray# s -> Int#
+
+## 0.12.0
+
+- Shipped with GHC 9.10.1
+
+- Add unaligned addr access primops. These primops will be emulated on platforms that don't support unaligned access.
+
+ readWord8OffAddrAsChar# :: Addr# -> Int# -> State# s -> (# State# s, Char# #)
+ readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# s -> (# State# s, Addr# #)
+ readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# s -> (# State# s, Float# #)
+ readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# s -> (# State# s, Double# #)
+ readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# s -> (# State# s, StablePtr# #)
+ readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# s -> (# State# s, Int16# #)
+ readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# s -> (# State# s, Int32# #)
+ readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# s -> (# State# s, Int64# #)
+ readWord8OffAddrAsInt# :: Addr# -> Int# -> State# s -> (# State# s, Int# #)
+
+ readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# s -> (# State# s, Word16# #)
+ readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# s -> (# State# s, Word32# #)
+ readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# s -> (# State# s, Word64# #)
+ readWord8OffAddrAsWord# :: Addr# -> Int# -> State# s -> (# State# s, Word# #)
+
+ indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
+ indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
+ indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
+ indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
+ indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr#
+ indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
+ indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
+ indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
+ indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
+
+ indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
+ indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
+ indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
+ indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
+
+ writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# s -> State# s
+ writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
+ writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# s -> State# s
+ writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# s -> State# s
+ writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# -> State# s -> State# s
+
+ writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# s -> State# s
+ writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# s -> State# s
+ writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# s -> State# s
+ writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# s -> State# s
+
+ writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# s -> State# s
+ writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# s -> State# s
+ writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# s -> State# s
+ writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# s -> State# s
+
+- The `unsafeThawByteArray#` primop was added, serving as a inverse to the existing
+ `unsafeFreezeByteArray#` primop (see #22710).
+
+- `dataToTag#` has been moved to `GHC.Magic` and made the sole method
+ of a new class:
+
+ ```haskell
+ type DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint
+ class DataToTag a where
+ dataToTag# :: a -> Int#
+ ```
+
+ In particular, it is now applicable only at some (not all)
+ lifted types. However, if `t` is an algebraic data type (i.e. `t`
+ matches a `data` or `data instance` declaration) with all of its
+ constructors in scope and the levity of `t` is statically known,
+ then the constraint `DataToTag t` can always be solved.
+
+- Renamed several built-in tycon syntaxes to avoid punning:
+
+ - Unboxed tuple tycons are now `Tuple#`
+ - Unboxed sum tycons are now `Sum#`
+ - Constraint tuple classes are now `CTuple`
+ - Unit tycons are now `Unit#`, `CUnit`.
+ - Solo tycons are now `Solo#`, `CSolo`.
+ - `Tuple` have been moved back to `GHC.Tuple`.
+
+ See [https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0475-tuple-syntax.rst].
+
+## 0.11.0
+
+- Shipped with GHC 9.8.1
+
+- Primitive pointer comparison functions are now levity-polymorphic, e.g.
+
+ ```haskell
+ sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
+ ```
+
+ This change affects the following functions:
+ - `sameArray#`, `sameMutableArray#`,
+ - `sameSmallArray#`, `sameSmallMutableArray#`,
+ - `sameMutVar#`, `sameTVar#`, `sameMVar#`
+ - `sameIOPort#`, `eqStableName#`.
+
+- `keepAlive#` and `touch#` are now polymorphic in their state token (#23163; [CLC#152](https://github.com/haskell/core-libraries-committee/issues/152))
+
+- Several new primops were added:
+
+ - `copyMutableByteArrayNonOverlapping#`
+ - `copyAddrToAddr#`
+ - `copyAddrToAddrNonOverlapping#`
+ - `setAddrRange#`
+
+- New primops for fused multiply-add operations. These primops combine a
+ multiplication and an addition, compiling to a single instruction when
+ the `-mfma` flag is enabled and the architecture supports it.
+
+ The new primops are `fmaddFloat#, fmsubFloat#, fnmaddFloat#, fnmsubFloat# :: Float# -> Float# -> Float# -> Float#`
+ and `fmaddDouble#, fmsubDouble#, fnmaddDouble#, fnmsubDouble# :: Double# -> Double# -> Double# -> Double#`.
+
+ These implement the following operations, while performing one single
+ rounding at the end, leading to a more accurate result:
+
+ - `fmaddFloat# x y z`, `fmaddDouble# x y z` compute `x * y + z`.
+ - `fmsubFloat# x y z`, `fmsubDouble# x y z` compute `x * y - z`.
+ - `fnmaddFloat# x y z`, `fnmaddDouble# x y z` compute `- x * y + z`.
+ - `fnmsubFloat# x y z`, `fnmsubDouble# x y z` compute `- x * y - z`.
+
+ Warning: on unsupported architectures, the software emulation provided by
+ the fallback to the C standard library is not guaranteed to be IEEE-compliant.
+
+- `Unit`, `Tuple0`, `Tuple1`, `Tuple2`, `Tuple3` and so on (up to `Tuple64`)
+ are now exported from `GHC.Tuple.Prim` and reexported from `GHC.Tuple`.
+ GHC now uses these as the actual names for tuple data types. As a result,
+ the "brackets with commas" syntax (e.g. `()`, `(,)`, etc.) now becomes just
+ an alias to these names. This change may affect tools and libraries that
+ rely on type names, such as `Generic` and Template Haskell.
+
+## 0.10.0
+
+- Shipped with GHC 9.6.1
+
+- The `listThreads#` primop was added, allowing the user to enumerate all
+ threads (running and blocked) in the program:
+ ```haskell
+ listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
+ ```
+
+- The type of the `labelThread#` primop was changed from:
+ ```haskell
+ labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
+ ```
+ to
+ ```haskell
+ labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
+ ```
+ Where the `ByteArray#` must contain a UTF-8-encoded string.
+
+- The `threadLabel#` primop was added, allowing the user to query the label of
+ a given `ThreadId#`.
+
+- `isByteArrayPinned#` now only considers an array pinned if it was explicitly pinned
+ by the user. This is required to avoid ghc issue [#22255](https://gitlab.haskell.org/ghc/ghc/-/issues/22255)
+ which showed that the old behaviour could cause segfaults when used in combination
+ with compact regions.
+ We are working on ways to allow users and library authors to get back the
+ performance benefits of the old behaviour where possible.
+
+- `List` is now exported from `GHC.Types`.
+
+## 0.9.0 *August 2022*
+
+- Shipped with GHC 9.4.1
+
+- `magicDict` has been renamed to `withDict` and is now defined in
+ `GHC.Magic.Dict` instead of `GHC.Prim`. `withDict` now has the type:
+
+ ```haskell
+ withDict :: forall {rr :: RuntimeRep} st dt (r :: TYPE rr). st -> (dt => r) -> r
+ ```
+
+ Unlike `magicDict`, `withDict` can be used without defining an
+ intermediate data type. For example, the `withTypeable` function from the
+ `Data.Typeable` module can now be defined as:
+
+ ```haskell
+ withTypeable :: forall k (a :: k) rep (r :: TYPE rep). ()
+ => TypeRep a -> (Typeable a => r) -> r
+ withTypeable rep k = withDict @(TypeRep a) @(Typeable a) rep k
+ ```
+
+ Note that the explicit type applications are required, as the call to
+ `withDict` would be ambiguous otherwise.
+
+- Primitive types and functions which handle boxed values are now levity-polymorphic,
+ meaning that they now also work with unlifted boxed values (i.e. values whose type
+ has kind `TYPE (BoxedRep Unlifted)`).
+
+ The following type constructors are now levity-polymorphic:
+
+ - `Array#`, `SmallArray#`, `Weak#`, `StablePtr#`, `StableName#`,
+
+ - `MutableArray#`, `SmallMutableArray#`, `MutVar#`,
+ `TVar#`, `MVar#`, `IOPort#`.
+
+ For example, `Array#` used to have kind:
+
+ ```haskell
+ Type -> UnliftedType
+ ```
+
+ but it now has kind:
+
+ ```haskell
+ forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
+ ```
+
+ Similarly, `MutVar#` used to have kind:
+
+ ```haskell
+ Type -> Type -> UnliftedType
+ ```
+
+ but it now has kind:
+
+ ```haskell
+ forall {l :: Levity}. Type -> TYPE (BoxedRep l) -> UnliftedType
+ ```
+
+ This means that in `Array# a`, `MutableArray# s a`, `MutVar# s a`, ...,
+ the element type `a`, must always be boxed, but it can now either be lifted
+ or unlifted.
+ In particular, arrays and mutable variables can now be used to store
+ other arrays and mutable variables.
+
+ All functions which use these updated primitive types are also levity-polymorphic:
+
+ - all array operations (reading/writing/copying/...), for both arrays and small arrays,
+ mutable and immutable:
+
+ - `newArray#`, `readArray#`, `writeArray#`, `sizeofArray#`, `sizeofMutableArray#`, `indexArray#`,
+ `unsafeFreezeArray#`, `unsafeThawArray#`, `copyArray#`, `copyMutableArray#`, `cloneArray#`,
+ `cloneMutableArray#`, `freezeArray#`, `thawArray#`, `casArray#`,
+
+ - `newSmallArray#`, `shrinkSmallMutableArray#`, `readSmallArray#`, `writeSmallArray#`, `sizeofSmallArray#`,
+ `getSizeofSmallMutableArray#`, `indexSmallArray#`, `unsafeFreezeSmallArray#`,
+ `unsafeThawSmallArray#`, `copySmallArray#`, `copySmallMutableArray#`, `cloneSmallArray#`,
+ `cloneSmallMutableArray#`, `freezeSmallArray#`, `thawSmallArray#`, `casSmallArray#`,
+
+ - `newMutVar#`, `readMutVar#`, `writeMutVar#`,`casMutVar#`,
+
+ - operations on `MVar#` and `TVar#`:
+
+ - `newTVar#`, `readTVar#`, `readTVarIO#`, `writeTVar#`,
+
+ - `newMVar#`, `takeMVar#`, `tryTakeMVar#`, `putMVar#`,
+ `tryPutMVar#`, `readMVar#`, `tryReadMVar#`,
+
+ - `STM` operations `atomically#`, `retry#`, `catchRetry#` and `catchSTM#`.
+
+ - `newIOPort#`, `readIOPort#`, `writeIOPort#`,
+
+ - `mkWeak#`, `mkWeakNoFinalizer#`, `addCFinalizerToWeak#`, `deRefWeak#`, `finalizeWeak#`,
+
+ - `makeStablePtr#`, `deRefStablePtr#`, `eqStablePtr#`, `makeStableName#`, `stableNameToInt#`,
+
+ For example, the full type of `newMutVar#` is now:
+
+ ```haskell
+ newMutVar#
+ :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)).
+ a -> State# s -> (# State# s, MVar# s a #)
+ ```
+
+ and the full type of `writeSmallArray#` is:
+
+ ```haskell
+ writeSmallArray#
+ :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)).
+ SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
+ ```
+
+- `ArrayArray#` and `MutableArrayArray#` have been moved from `GHC.Prim` to `GHC.Exts`.
+ They are deprecated, because their functionality is now subsumed by `Array#`
+ and `MutableArray#`.
+
+- `mkWeak#`, `mkWeakNoFinalizer#`, `touch#` and `keepAlive#` are now
+ levity-polymorphic instead of representation-polymorphic. For instance:
+
+ ```haskell
+ mkWeakNoFinalizer#
+ :: forall {l :: Levity} {k :: Levity}
+ (a :: TYPE ('BoxedRep l))
+ (b :: TYPE ('BoxedRep k)).
+ a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+ ```
+
+ That is, the type signature now quantifies over the `Levity` of `a`
+ instead of its `RuntimeRep`. In addition, this variable is now inferred,
+ instead of specified, meaning that it is no longer eligible for visible type application.
+ Note that `b` is now also levity-polymorphic, due to the change outlined in the
+ previous point.
+
+- Primitive functions for throwing and catching exceptions are now more polymorphic
+ than before. For example, `catch#` now has type:
+
+ ```haskell
+ catch#
+ :: forall {r :: RuntimeRep} {l :: Levity}
+ (a :: TYPE r)
+ (b :: TYPE ('BoxedRep l)).
+ ( State# RealWorld -> (# State# RealWorld, a #) )
+ -> ( b -> State# RealWorld -> (# State# RealWorld, a #) )
+ -> State# RealWorld -> (# State# RealWorld, a #)
+ ```
+
+ The following functions are concerned:
+
+ - `catch#`,
+
+ - `raise#`, `raiseIO#`,
+
+ - `maskAsyncExceptions#`, `maskUninterruptible#`, `unmaskAsyncExceptions#`.
+
+ Note in particular that `raise#` is now both representation-polymorphic
+ (with an inferred `RuntimeRep` argument) and levity-polymorphic, with type:
+
+ ```haskell
+ raise# :: forall {l :: Levity} {r :: RuntimeRep}
+ (a :: TYPE (BoxedRep l))
+ (b :: TYPE r).
+ a -> b
+ ```
+
+- ``fork#`` and ``forkOn#`` are now representation-polymorphic. For example, ``fork#``
+ now has type: ::
+
+ fork# :: forall {r :: RuntimeRep} (a :: TYPE r).
+ (State# RealWorld -> (# State# RealWorld, a #))
+ -> (State# RealWorld -> (# State# RealWorld, a #))
+
+- `reallyUnsafePtrEquality#` has been made more general, as it is now
+ both levity-polymorphic and heterogeneous:
+
+ ```haskell
+ reallyUnsafePtrEquality#
+ :: forall {l :: Levity} {k :: Levity}
+ (a :: TYPE (BoxedRep l))
+ (b :: TYPE (BoxedRep k))
+ . a -> b -> Int#
+ ```
+
+ This means that `reallyUnsafePtrEquality#` can be used on primitive arrays
+ such as `Array#` and `ByteArray#`. It can also be used on values of
+ different types, without needing to call `unsafeCoerce#`.
+
+- The following functions have been moved from `GHC.Prim` to `GHC.Exts`:
+ - `sameMutableArray#`, `sameSmallMutableArray#`, `sameMutableByteArray#`
+ and `sameMutableArrayArray#`,
+ - `sameMutVar#`, `sameTVar#` and`sameMVar#`,
+ - `sameIOPort#`,
+ - `eqStableName#`.
+
+- The following functions have been added to `GHC.Exts`:
+
+ ```haskell
+ sameArray# :: Array# a -> Array# a -> Int#
+ sameSmallArray# :: SmallArray# a -> SmallArray# a -> Int#
+ sameByteArray# :: ByteArray# -> ByteArray# -> Int#
+ sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#
+ ```
+
+## 0.8.0
+
+- Change array access primops to use type with size maxing the element size:
+
+ - `index{Int,Word}Array# :: ByteArray# -> Int# -> {Int,Word}#`
+ - `indexWord8ArrayAs{Int,Word}# :: ByteArray# -> Int# -> {Int,Word}#`
+ - `read{Int,Word}Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}# #)`
+ - `write{Int,Word}Array# :: MutableByteArray# s -> Int# -> {Int,Word}# -> State# s -> State# s`
+ - `readWord8ArrayAs{Int,Word}# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}# #)`
+ - `writeWord8ArrayAs{Int,Word}# :: MutableByteArray# s -> Int# -> {Int,Word}# -> State# s -> State# s`
+
+ This was already the for the 64-bit access primops, but not the smaller ones.
+
+- Rename some numeric prim type conversion primops:
+
+ - `extend{Int,Word}#` -> `extendTo{Int,Word}#`
+ - `narrow{Int,Word}#` -> `intTo{Int,Word}#`
+
+- Add primops for atomic compare and swap for sizes other that wordsize:
+
+ casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s, Int8# #)
+ casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s, Int16# #)
+ casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s, Int32# #)
+ casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s, Int64# #)
+ atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s, Word8# #)
+ atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s, Word16# #)
+ atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s, Word32# #)
+ atomicCasWord64Addr# :: Addr# -> WORD64 -> WORD64 -> State# s -> (# State# s, WORD64 #)
+
+## 0.7.0
+
+- Shipped with GHC 9.0.1
+
+- Add known-key `cstringLength#` to `GHC.CString`. This is just the
+ C function `strlen`, but a built-in rewrite rule allows GHC to
+ compute the result at compile time when the argument is known.
+
+- In order to support unicode better the following functions in `GHC.CString`
+ gained UTF8 counterparts:
+
+ unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char]
+ unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a
+
+- unpackFoldrCString* variants can now inline in phase [0].
+
+ If the folding function is known this allows for unboxing of the
+ Char argument resulting in much faster code.
+
+- Renamed the singleton tuple `GHC.Tuple.Unit` to `GHC.Tuple.Solo`.
+
+- Add primops for atomic exchange:
+
+ atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s, Addr# #)
+ atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #)
+
+- Add primops for atomic compare and swap at a given Addr#:
+
+ atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s, Addr# #)
+ atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s, Word# #)
+
+- Add an explicit fixity for `(~)` and `(~~)`:
+
+ infix 4 ~, ~~
+
+- Introduce `keepAlive#` to replace `touch#` in controlling object lifetime without
+ the soundness issues of the latter (see
+ [#17760](https://gitlab.haskell.org/ghc/ghc/-/issues/17760)).
+
+## 0.6.1
+
+- Shipped with GHC 8.10.1
+
+- Add primop for shrinking `SmallMutableArray#`
+ to `GHC.Prim`:
+
+ shrinkSmallMutableArray# :: SmallMutableArray# s a -> Int# -> State# s -> State# s
+
+ Note that `resizeSmallMutableArray#` is not included as
+ as primitive. It has been implemented in library space in
+ `GHC.Exts`. See the release notes of `base`.
+
+- Added to `GHC.Prim`:
+
+ closureSize# :: a -> Int#
+
+- Added to `GHC.Prim`:
+
+ bitReverse# :: Word# -> Word#
+ bitReverse8# :: Word# -> Word#
+ bitReverse16# :: Word# -> Word#
+ bitReverse32# :: Word# -> Word#
+ bitReverse64# :: Word# -> Word#
+
+ `bitReverse#` is a primop that, for a `Word` of 8, 16, 32 or 64 bits,
+ reverses the order of its bits e.g. `0b110001` becomes `0b100011`.
+ These primitives use optimized machine instructions when available.
+
+- Add Int# multiplication primop:
+
+ timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
+
+ `timesInt2#` computes the multiplication of its two parameters and returns a
+ triple (isHighNeeded,high,low) where high and low are respectively the high
+ and low bits of the double-word result. isHighNeeded is a cheap way to test
+ if the high word is a sign-extension of the low word (isHighNeeded = 0#) or
+ not (isHighNeeded = 1#).
+
+## 0.6.0
+
+- Shipped with GHC 8.8.1
+
+- Added to `GHC.Prim`:
+
+ traceBinaryEvent# :: Addr# -> Int# -> State# s -> State# s
+
+## 0.5.3
+
+- Shipped with GHC 8.6.1
+
+- Added to `GHC.Prim`:
+
+ addWordC# :: Word# -> Word# -> (# Word#, Int# #)
+
+- `unpackClosure#` can now unpack any valid Haskell closure.
+ Previously it returned empty pointer and non-pointer arrays
+ for thunks.
+
+- Add unaligned bytearray access primops (#4442)
+
+ readWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
+ readWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
+ readWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
+ readWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
+ readWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# #)
+ readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16# #)
+ readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32# #)
+ readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #)
+ readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+
+ readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16# #)
+ readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32# #)
+ readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #)
+ readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
+
+ writeWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
+ writeWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
+ writeWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
+ writeWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
+ writeWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> StablePtr# -> State# s -> State# s
+
+ writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
+ writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
+ writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
+ writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+
+ writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
+ writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
+ writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
+ writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
+
+## 0.5.2.0
+
+- Shipped with GHC 8.4.1
+
+- Added to `GHC.Prim`:
+
+ compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
+
+- Don't allocate a thunk for each unpacked UTF-8 character in `unpackCStringUtf8#`
+
+## 0.5.1.1 *November 2017*
+
+- Shipped with GHC 8.2.2
+
+- Changed strictness properties of `catchRetry#` (#14171)
+
+## 0.5.1.0 *July 2017*
+
+- Shipped with GHC 8.2.1
+
+- Added to `GHC.Prim`:
+
+ fabsDouble# :: Double# -> Double#
+ fabsFloat# :: Float# -> Float#
+ isByteArrayPinned# :: ByteArray# -> Int#
+ isMutableByteArrayPinned# :: MutableByteArray# s -> Int#
+ anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
+
+- New primitives for compact regions in `GHC.Prim`:
+
+ Compact#
+ compactNew#
+ compactResize#
+ compactContains#
+ compactContainsAny#
+ compactGetFirstBlock#
+ compactGetNextBlock#
+ compactAllocateBlock#
+ compactFixupPointers#
+ compactAdd#
+ compactAddWithSharing#
+ compactSize#
+
+- Generalised `noDuplicate#` from
+
+ noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
+
+ to
+
+ noDuplicate# :: State# s -> State# s
+
+
+## 0.5.0.0
+
+- Shipped with GHC 8.0.1
+
+- `GHC.Classes`: new `class IP (a :: Symbol) b | a -> b`
+
+- `GHC.Prim`: changed type signatures from
+
+ check# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, () #)
+ finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, () #) #)
+ mkWeak# :: a -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+
+ to
+
+ check# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> State# RealWorld
+ finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
+ mkWeak# :: a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+
+- Removed from `GHC.Prim`:
+
+ parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
+ parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+ parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
+ parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+ parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+ parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
+
+- Added to `GHC.Prim`:
+
+ getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
+ subWordC# :: Word# -> Word# -> (# Word#, Int# #)
+ runRW# :: (State# RealWorld -> (# State# RealWorld, o #)) -> (# State# RealWorld, o #)
+
+- Added to `GHC.Types`:
+
+ data Module = Module TrName TrName
+ data Nat
+ data Symbol
+ data TrName = TrNameS Addr# | TrNameD [Char]
+ data TyCon = TyCon Word# Word# Module TrName
diff --git a/ghc-prim.cabal b/ghc-prim.cabal
--- a/ghc-prim.cabal
+++ b/ghc-prim.cabal
@@ -1,26 +1,35 @@
+cabal-version: 2.2
name: ghc-prim
-version: 0.4.0.0
--- GHC 7.8.4 released with 0.3.1.0
-license: BSD3
+version: 0.13.0
+-- NOTE: Don't forget to update ./changelog.md
+license: BSD-3-Clause
license-file: LICENSE
category: GHC
maintainer: libraries@haskell.org
-bug-reports: http://ghc.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29&keywords=ghc-prim
+bug-reports: https://gitlab.haskell.org/ghc/ghc/issues/new
synopsis: GHC primitives
-cabal-version: >=1.10
build-type: Custom
description:
- GHC primitives.
+ This package contains the primitive types and operations supplied by GHC.
+ It is an internal package, only for the use of GHC developers.
+ GHC users should not use it! If you do use it then expect
+ breaking changes at any time without warning. You should prefer
+ to import @GHC.Exts@ from the @base@ package instead.
+
+extra-source-files: changelog.md
+
source-repository head
type: git
- location: http://git.haskell.org/ghc.git
+ location: https://gitlab.haskell.org/ghc/ghc.git
subdir: libraries/ghc-prim
-flag include-ghc-prim
- Description: Include GHC.Prim in exposed-modules
- default: False
+custom-setup
+ setup-depends: base >= 4 && < 5, process, filepath, directory, Cabal >= 1.23 && < 3.9
+flag need-atomic
+ default: False
+
Library
default-language: Haskell2010
other-extensions:
@@ -42,25 +51,57 @@
GHC.CString
GHC.Classes
GHC.Debug
- GHC.IntWord64
GHC.Magic
+ GHC.Magic.Dict
+ GHC.Prim.Ext
+ GHC.Prim.Panic
+ GHC.Prim.Exception
+ GHC.Prim.PtrEq
GHC.PrimopWrappers
GHC.Tuple
GHC.Types
- if flag(include-ghc-prim)
- exposed-modules: GHC.Prim
+ virtual-modules:
+ GHC.Prim
- c-sources:
- cbits/atomic.c
- cbits/bswap.c
- cbits/clz.c
- cbits/ctz.c
- cbits/debug.c
- cbits/longlong.c
- cbits/popcnt.c
- cbits/word2float.c
+ -- OS Specific
+ if os(windows)
+ -- Windows requires some extra libraries for linking because the RTS
+ -- is no longer re-exporting them (see #11223)
+ -- ucrt: standard C library. The RTS will automatically include this,
+ -- but is added for completeness.
+ -- mingwex: provides GNU POSIX extensions that aren't provided by ucrt.
+ -- mingw32: Unfortunately required because of a resource leak between
+ -- mingwex and mingw32. the __math_err symbol is defined in
+ -- mingw32 which is required by mingwex.
+ -- user32: provides access to apis to modify user components (UI etc)
+ -- on Windows. Required because of mingw32.
+ extra-libraries: user32, mingw32, mingwex, ucrt
- -- We need to set the package key to ghc-prim (without a version number)
+ if os(linux)
+ -- we need libm, but for musl and other's we might need libc, as libm
+ -- is just an empty shell.
+ extra-libraries: c, m
+
+ if flag(need-atomic)
+ -- for 64-bit atomic ops on armel (#20549)
+ extra-libraries: atomic
+
+ if !os(ghcjs)
+ c-sources:
+ cbits/atomic.c
+ cbits/bswap.c
+ cbits/bitrev.c
+ cbits/clz.c
+ cbits/ctz.c
+ cbits/debug.c
+ cbits/longlong.c
+ cbits/mulIntMayOflo.c
+ cbits/pdep.c
+ cbits/pext.c
+ cbits/popcnt.c
+ cbits/word2float.c
+
+ -- We need to set the unit ID to ghc-prim (without a version number)
-- as it's magic.
- ghc-options: -this-package-key ghc-prim
+ ghc-options: -this-unit-id ghc-prim