packages feed

ghc-prim 0.3.1.0 → 0.13.0

raw patch · 26 files changed

Files

GHC/CString.hs view
@@ -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#)))
GHC/Classes.hs view
@@ -1,296 +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.------------------------------------------------------------------------------------- #hide-module GHC.Classes where---- GHC.Magic is used in some derived instances-import GHC.Magic ()-import GHC.Prim-import GHC.Tuple-import GHC.Types---infix  4  ==, /=, <, <=, >=, >-infixr 3  &&-infixr 2  ||--default ()              -- Double isn't available yet---- | The 'Eq' class defines equality ('==') and inequality ('/=').--- All the basic datatypes exported by the "Prelude" are instances of 'Eq',--- and 'Eq' may be derived for any datatype whose constituents are also--- instances of 'Eq'.------ Minimal complete definition: either '==' or '/='.----class  Eq a  where-    (==), (/=)           :: a -> a -> Bool--    {-# INLINE (/=) #-}-    {-# INLINE (==) #-}-    x /= y               = not (x == y)-    x == y               = not (x /= y)-    {-# MINIMAL (==) | (/=) #-}--deriving instance Eq ()-deriving instance (Eq  a, Eq  b) => Eq  (a, b)-deriving instance (Eq  a, Eq  b, Eq  c) => Eq  (a, b, c)-deriving instance (Eq  a, Eq  b, Eq  c, Eq  d) => Eq  (a, b, c, d)-deriving instance (Eq  a, Eq  b, Eq  c, Eq  d, Eq  e) => Eq  (a, b, c, d, e)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f)-               => Eq (a, b, c, d, e, f)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g)-               => Eq (a, b, c, d, e, f, g)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h)-               => Eq (a, b, c, d, e, f, g, h)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i)-               => Eq (a, b, c, d, e, f, g, h, i)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j)-               => Eq (a, b, c, d, e, f, g, h, i, j)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j, Eq k)-               => Eq (a, b, c, d, e, f, g, h, i, j, k)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j, Eq k, Eq l)-               => Eq (a, b, c, d, e, f, g, h, i, j, k, l)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j, Eq k, Eq l, Eq m)-               => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n)-               => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)-deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,-                   Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o)-               => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)--instance (Eq a) => Eq [a] where-    {-# SPECIALISE instance Eq [Char] #-}-    []     == []     = True-    (x:xs) == (y:ys) = x == y && xs == ys-    _xs    == _ys    = False--deriving instance Eq Bool-deriving instance Eq Ordering-deriving instance Eq Word--instance Eq Char where-    (C# c1) == (C# c2) = isTrue# (c1 `eqChar#` c2)-    (C# c1) /= (C# c2) = isTrue# (c1 `neChar#` c2)--instance Eq Float where-    (F# x) == (F# y) = isTrue# (x `eqFloat#` y)--instance Eq Double where-    (D# x) == (D# y) = isTrue# (x ==## y)--instance Eq Int where-    (==) = eqInt-    (/=) = neInt--{-# INLINE eqInt #-}-{-# INLINE neInt #-}-eqInt, neInt :: Int -> Int -> Bool-(I# x) `eqInt` (I# y) = isTrue# (x ==# y)-(I# x) `neInt` (I# y) = isTrue# (x /=# y)---- | The 'Ord' class is used for totally ordered datatypes.------ Instances of 'Ord' can be derived for any user-defined--- datatype whose constituent types are in 'Ord'.  The declared order--- of the constructors in the data declaration determines the ordering--- in derived 'Ord' instances.  The 'Ordering' datatype allows a single--- comparison to determine the precise ordering of two objects.------ Minimal complete definition: either 'compare' or '<='.--- Using 'compare' can be more efficient for complex types.----class  (Eq a) => Ord a  where-    compare              :: a -> a -> Ordering-    (<), (<=), (>), (>=) :: a -> a -> Bool-    max, min             :: a -> a -> a--    compare x y = if x == y then EQ-                  -- NB: must be '<=' not '<' to validate the-                  -- above claim about the minimal things that-                  -- can be defined for an instance of Ord:-                  else if x <= y then LT-                  else GT--    x <  y = case compare x y of { LT -> True;  _ -> False }-    x <= y = case compare x y of { GT -> False; _ -> True }-    x >  y = case compare x y of { GT -> True;  _ -> False }-    x >= y = case compare x y of { LT -> False; _ -> True }--        -- These two default methods use '<=' rather than 'compare'-        -- because the latter is often more expensive-    max x y = if x <= y then y else x-    min x y = if x <= y then x else y-    {-# MINIMAL compare | (<=) #-}--deriving instance Ord ()-deriving instance (Ord a, Ord b) => Ord (a, b)-deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c)-deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f)-               => Ord (a, b, c, d, e, f)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g)-               => Ord (a, b, c, d, e, f, g)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h)-               => Ord (a, b, c, d, e, f, g, h)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i)-               => Ord (a, b, c, d, e, f, g, h, i)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j)-               => Ord (a, b, c, d, e, f, g, h, i, j)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j, Ord k)-               => Ord (a, b, c, d, e, f, g, h, i, j, k)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j, Ord k, Ord l)-               => Ord (a, b, c, d, e, f, g, h, i, j, k, l)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j, Ord k, Ord l, Ord m)-               => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n)-               => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)-deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,-                   Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o)-               => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)--instance (Ord a) => Ord [a] where-    {-# SPECIALISE instance Ord [Char] #-}-    compare []     []     = EQ-    compare []     (_:_)  = LT-    compare (_:_)  []     = GT-    compare (x:xs) (y:ys) = case compare x y of-                                EQ    -> compare xs ys-                                other -> other--deriving instance Ord Bool-deriving instance Ord Ordering-deriving instance Ord Word---- We don't use deriving for Ord Char, because for Ord the derived--- instance defines only compare, which takes two primops.  Then--- '>' uses compare, and therefore takes two primops instead of one.-instance Ord Char where-    (C# c1) >  (C# c2) = isTrue# (c1 `gtChar#` c2)-    (C# c1) >= (C# c2) = isTrue# (c1 `geChar#` c2)-    (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2)-    (C# c1) <  (C# c2) = isTrue# (c1 `ltChar#` c2)--instance Ord Float where-    (F# x) `compare` (F# y)-        = if      isTrue# (x `ltFloat#` y) then LT-          else if isTrue# (x `eqFloat#` y) then EQ-          else                                  GT--    (F# x) <  (F# y) = isTrue# (x `ltFloat#` y)-    (F# x) <= (F# y) = isTrue# (x `leFloat#` y)-    (F# x) >= (F# y) = isTrue# (x `geFloat#` y)-    (F# x) >  (F# y) = isTrue# (x `gtFloat#` y)--instance Ord Double where-    (D# x) `compare` (D# y)-        = if      isTrue# (x <##  y) then LT-          else if isTrue# (x ==## y) then EQ-          else                            GT--    (D# x) <  (D# y) = isTrue# (x <##  y)-    (D# x) <= (D# y) = isTrue# (x <=## y)-    (D# x) >= (D# y) = isTrue# (x >=## y)-    (D# x) >  (D# y) = isTrue# (x >##  y)--instance Ord Int where-    compare = compareInt-    (<)     = ltInt-    (<=)    = leInt-    (>=)    = geInt-    (>)     = gtInt--{-# INLINE gtInt #-}-{-# INLINE geInt #-}-{-# INLINE ltInt #-}-{-# INLINE leInt #-}-gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool-(I# x) `gtInt` (I# y) = isTrue# (x >#  y)-(I# x) `geInt` (I# y) = isTrue# (x >=# y)-(I# x) `ltInt` (I# y) = isTrue# (x <#  y)-(I# x) `leInt` (I# y) = isTrue# (x <=# y)--compareInt :: Int -> Int -> Ordering-(I# x#) `compareInt` (I# y#) = compareInt# x# y#--compareInt# :: Int# -> Int# -> Ordering-compareInt# x# y#-    | isTrue# (x# <#  y#) = LT-    | isTrue# (x# ==# y#) = EQ-    | True                = GT---- OK, so they're technically not part of a class...:---- Boolean functions---- | Boolean \"and\"-(&&)                    :: Bool -> Bool -> Bool-True  && x              =  x-False && _              =  False---- | Boolean \"or\"-(||)                    :: Bool -> Bool -> Bool-True  || _              =  True-False || x              =  x---- | Boolean \"not\"-not                     :: Bool -> Bool-not True                =  False-not False               =  True------------------------------------------------------------------------------ These don't really belong here, but we don't have a better place to--- put them--divInt# :: Int# -> Int# -> Int#-x# `divInt#` y#-        -- Be careful NOT to overflow if we do any additional arithmetic-        -- on the arguments...  the following  previous version of this-        -- code has problems with overflow:---    | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y#---    | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y#-    =      if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#-      else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#-      else x# `quotInt#` y#--modInt# :: Int# -> Int# -> Int#-x# `modInt#` y#-    = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) ||-         isTrue# (x# <# 0#) && isTrue# (y# ># 0#)-      then if isTrue# (r# /=# 0#) then r# +# y# else 0#-      else r#-    where-    !r# = x# `remInt#` y#+{-# 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
GHC/Debug.hs view
@@ -1,9 +1,15 @@-{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes, Trustworthy #-}+{-# 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 ()
− GHC/IntWord64.hs 
@@ -1,72 +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"---- #hide-module GHC.IntWord64 (-#if WORD_SIZE_IN_BITS < 64-        Int64#, Word64#, module GHC.IntWord64-#endif-    ) where--#if WORD_SIZE_IN_BITS < 64-import GHC.Prim--foreign import ccall unsafe "hs_eqWord64"    eqWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_neWord64"    neWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_ltWord64"    ltWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_leWord64"    leWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_gtWord64"    gtWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_geWord64"    geWord64#     :: Word64# -> Word64# -> Int#--foreign import ccall unsafe "hs_eqInt64"     eqInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_neInt64"     neInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_ltInt64"     ltInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_leInt64"     leInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_gtInt64"     gtInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_geInt64"     geInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_quotInt64"   quotInt64#    :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_remInt64"    remInt64#     :: Int64# -> Int64# -> Int64#--foreign import ccall unsafe "hs_plusInt64"   plusInt64#    :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_minusInt64"  minusInt64#   :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_timesInt64"  timesInt64#   :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_negateInt64" negateInt64#  :: Int64# -> Int64#-foreign import ccall unsafe "hs_quotWord64"  quotWord64#   :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_remWord64"   remWord64#    :: Word64# -> Word64# -> Word64#--foreign import ccall unsafe "hs_and64"       and64#        :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_or64"        or64#         :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_xor64"       xor64#        :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_not64"       not64#        :: Word64# -> Word64#--foreign import ccall unsafe "hs_uncheckedShiftL64"   uncheckedShiftL64#   :: Word64# -> Int# -> Word64#-foreign import ccall unsafe "hs_uncheckedShiftRL64"  uncheckedShiftRL64#  :: Word64# -> Int# -> Word64#-foreign import ccall unsafe "hs_uncheckedIShiftL64"  uncheckedIShiftL64#  :: Int64# -> Int# -> Int64#-foreign import ccall unsafe "hs_uncheckedIShiftRA64" uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#-foreign import ccall unsafe "hs_uncheckedIShiftRL64" uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#--foreign import ccall unsafe "hs_int64ToWord64"   int64ToWord64#   :: Int64# -> Word64#-foreign import ccall unsafe "hs_word64ToInt64"   word64ToInt64#   :: Word64# -> Int64#-foreign import ccall unsafe "hs_intToInt64"      intToInt64#      :: Int# -> Int64#-foreign import ccall unsafe "hs_int64ToInt"      int64ToInt#      :: Int64# -> Int#-foreign import ccall unsafe "hs_wordToWord64"    wordToWord64#    :: Word# -> Word64#-foreign import ccall unsafe "hs_word64ToWord"    word64ToWord#    :: Word64# -> Word#--#endif-
GHC/Magic.hs view
@@ -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 ) where+module GHC.Magic ( inline, noinline, lazy, oneShot, runRW#, DataToTag(..) ) where --- | The call '(inline f)' arranges that 'f' is inlined, regardless of--- its size. More precisely, the call '(inline f)' rewrites to the--- right-hand side of 'f'\'s definition. This allows the programmer to+--------------------------------------------------+--        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'+-- size of @f@'s definition; it is unconditional. The main caveat is+-- that @f@'s definition must be visible to the compiler; it is+-- therefore recommended to mark the function with an @INLINABLE@ -- pragma at its definition so that GHC guarantees to record its -- unfolding regardless of size. --@@ -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,15 +76,64 @@ -- > 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 ++-- | The 'oneShot' function can be used to give a hint to the compiler that its+-- argument will be called at most once, which may (or may not) enable certain+-- optimizations. It can be useful to improve the performance of code in continuation+-- passing style.+--+-- If 'oneShot' is used wrongly, then it may be that computations whose result+-- that would otherwise be shared are re-evaluated every time they are used. Otherwise,+-- the use of `oneShot` is safe.+--+-- 'oneShot' is 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 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#
+ GHC/Magic/Dict.hs view
@@ -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.+-}
− GHC/Prim.hs 
@@ -1,6291 +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 MagicHash, MultiParamTypeClasses, NoImplicitPrelude, UnboxedTuples #-}-module GHC.Prim (-	--- * The word size story.--- |Haskell98 specifies that signed integers (type @Int@)--- 	 must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals--- 	 the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@.--- 	 This is normally set based on the @config.h@ parameter--- 	 @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64--- 	 bits on 64-bit machines.  However, it can also be explicitly--- 	 set to a smaller number, e.g., 31 bits, to allow the--- 	 possibility of using tag bits. Currently GHC itself has only--- 	 32-bit and 64-bit variants, but 30 or 31-bit code can be--- 	 exported as an external core file for use in other back ends.--- --- 	 GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@.--- --- 	 In addition, GHC supports families of explicit-sized integers--- 	 and words at 8, 16, 32, and 64 bits, with the usual--- 	 arithmetic operations, comparisons, and a range of--- 	 conversions.  The 8-bit and 16-bit sizes are always--- 	 represented as @Int\#@ and @Word\#@, and the--- 	 operations implemented in terms of the the primops on these--- 	 types, with suitable range restrictions on the results (using--- 	 the @narrow$n$Int\#@ and @narrow$n$Word\#@ families--- 	 of primops.  The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@--- 	 $\geq$ 32; otherwise, these are represented using distinct--- 	 primitive types @Int32\#@ and @Word32\#@. These (when--- 	 needed) have a complete set of corresponding operations;--- 	 however, nearly all of these are implemented as external C--- 	 functions rather than as primops.  Exactly the same story--- 	 applies to the 64-bit sizes.  All of these details are hidden--- 	 under the @PrelInt@ and @PrelWord@ modules, which use--- 	 @\#if@-defs to invoke the appropriate types and--- 	 operators.--- --- 	 Word size also matters for the families of primops for--- 	 indexing\/reading\/writing fixed-size quantities at offsets--- 	 from an array base, address, or foreign pointer.  Here, a--- 	 slightly different approach is taken.  The names of these--- 	 primops are fixed, but their /types/ vary according to--- 	 the value of @WORD\_SIZE\_IN\_BITS@. For example, if word--- 	 size is at least 32 bits then an operator like--- 	 @indexInt32Array\#@ has type @ByteArray\# -> Int\# 	 -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> 	 Int32\#@.  This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed--- 	 in the files that expose these primops.--- --- 	 Finally, there are strongly deprecated primops for coercing---          between @Addr\#@, the primitive type of machine---          addresses, and @Int\#@.  These are pretty bogus anyway,---          but will work on existing 32-bit and 64-bit GHC targets; they---          are completely bogus when tag bits are used in @Int\#@,---          so are not available in this case.  ---	--- * Char#--- |Operations on 31-bit characters.---	Char#,-	gtChar#,-	geChar#,-	eqChar#,-	neChar#,-	ltChar#,-	leChar#,-	ord#,-	--- * Int#--- |Operations on native-size integers (30+ bits).---	Int#,-	(+#),-	(-#),-	(*#),-	mulIntMayOflo#,-	quotInt#,-	remInt#,-	quotRemInt#,-	andI#,-	orI#,-	xorI#,-	notI#,-	negateInt#,-	addIntC#,-	subIntC#,-	(>#),-	(>=#),-	(==#),-	(/=#),-	(<#),-	(<=#),-	chr#,-	int2Word#,-	int2Float#,-	int2Double#,-	word2Float#,-	word2Double#,-	uncheckedIShiftL#,-	uncheckedIShiftRA#,-	uncheckedIShiftRL#,-	--- * Word#--- |Operations on native-sized unsigned words (30+ bits).---	Word#,-	plusWord#,-	plusWord2#,-	minusWord#,-	timesWord#,-	timesWord2#,-	quotWord#,-	remWord#,-	quotRemWord#,-	quotRemWord2#,-	and#,-	or#,-	xor#,-	not#,-	uncheckedShiftL#,-	uncheckedShiftRL#,-	word2Int#,-	gtWord#,-	geWord#,-	eqWord#,-	neWord#,-	ltWord#,-	leWord#,-	popCnt8#,-	popCnt16#,-	popCnt32#,-	popCnt64#,-	popCnt#,-	byteSwap16#,-	byteSwap32#,-	byteSwap64#,-	byteSwap#,-	--- * Narrowings--- |Explicit narrowing of native-sized ints or words.---	narrow8Int#,-	narrow16Int#,-	narrow32Int#,-	narrow8Word#,-	narrow16Word#,-	narrow32Word#,-	--- * Double#--- |Operations on double-precision (64 bit) floating-point numbers.---	Double#,-	(>##),-	(>=##),-	(==##),-	(/=##),-	(<##),-	(<=##),-	(+##),-	(-##),-	(*##),-	(/##),-	negateDouble#,-	double2Int#,-	double2Float#,-	expDouble#,-	logDouble#,-	sqrtDouble#,-	sinDouble#,-	cosDouble#,-	tanDouble#,-	asinDouble#,-	acosDouble#,-	atanDouble#,-	sinhDouble#,-	coshDouble#,-	tanhDouble#,-	(**##),-	decodeDouble_2Int#,-	--- * Float#--- |Operations on single-precision (32-bit) floating-point numbers.---	Float#,-	gtFloat#,-	geFloat#,-	eqFloat#,-	neFloat#,-	ltFloat#,-	leFloat#,-	plusFloat#,-	minusFloat#,-	timesFloat#,-	divideFloat#,-	negateFloat#,-	float2Int#,-	expFloat#,-	logFloat#,-	sqrtFloat#,-	sinFloat#,-	cosFloat#,-	tanFloat#,-	asinFloat#,-	acosFloat#,-	atanFloat#,-	sinhFloat#,-	coshFloat#,-	tanhFloat#,-	powerFloat#,-	float2Double#,-	decodeFloat_Int#,-	--- * Arrays--- |Operations on @Array\#@.---	Array#,-	MutableArray#,-	newArray#,-	sameMutableArray#,-	readArray#,-	writeArray#,-	sizeofArray#,-	sizeofMutableArray#,-	indexArray#,-	unsafeFreezeArray#,-	unsafeThawArray#,-	copyArray#,-	copyMutableArray#,-	cloneArray#,-	cloneMutableArray#,-	freezeArray#,-	thawArray#,-	casArray#,-	--- * Byte Arrays--- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of---          raw memory in the garbage-collected heap, which is not---          scanned for pointers. It carries its own size (in bytes).---          There are---          three sets of operations for accessing byte array contents:---          index for reading from immutable byte arrays, and read\/write---          for mutable byte arrays.  Each set contains operations for a---          range of useful primitive data types.  Each operation takes---          an offset measured in terms of the size of the primitive type---          being read or written.---	ByteArray#,-	MutableByteArray#,-	newByteArray#,-	newPinnedByteArray#,-	newAlignedPinnedByteArray#,-	byteArrayContents#,-	sameMutableByteArray#,-	unsafeFreezeByteArray#,-	sizeofByteArray#,-	sizeofMutableByteArray#,-	indexCharArray#,-	indexWideCharArray#,-	indexIntArray#,-	indexWordArray#,-	indexAddrArray#,-	indexFloatArray#,-	indexDoubleArray#,-	indexStablePtrArray#,-	indexInt8Array#,-	indexInt16Array#,-	indexInt32Array#,-	indexInt64Array#,-	indexWord8Array#,-	indexWord16Array#,-	indexWord32Array#,-	indexWord64Array#,-	readCharArray#,-	readWideCharArray#,-	readIntArray#,-	readWordArray#,-	readAddrArray#,-	readFloatArray#,-	readDoubleArray#,-	readStablePtrArray#,-	readInt8Array#,-	readInt16Array#,-	readInt32Array#,-	readInt64Array#,-	readWord8Array#,-	readWord16Array#,-	readWord32Array#,-	readWord64Array#,-	writeCharArray#,-	writeWideCharArray#,-	writeIntArray#,-	writeWordArray#,-	writeAddrArray#,-	writeFloatArray#,-	writeDoubleArray#,-	writeStablePtrArray#,-	writeInt8Array#,-	writeInt16Array#,-	writeInt32Array#,-	writeInt64Array#,-	writeWord8Array#,-	writeWord16Array#,-	writeWord32Array#,-	writeWord64Array#,-	copyByteArray#,-	copyMutableByteArray#,-	copyByteArrayToAddr#,-	copyMutableByteArrayToAddr#,-	copyAddrToByteArray#,-	setByteArray#,-	casIntArray#,-	fetchAddIntArray#,-	--- * Arrays of arrays--- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed}--- 	 arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types,--- 	 just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@.--- 	 We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific--- 	 indexing, reading, and writing.---	ArrayArray#,-	MutableArrayArray#,-	newArrayArray#,-	sameMutableArrayArray#,-	unsafeFreezeArrayArray#,-	sizeofArrayArray#,-	sizeofMutableArrayArray#,-	indexByteArrayArray#,-	indexArrayArrayArray#,-	readByteArrayArray#,-	readMutableByteArrayArray#,-	readArrayArrayArray#,-	readMutableArrayArrayArray#,-	writeByteArrayArray#,-	writeMutableByteArrayArray#,-	writeArrayArrayArray#,-	writeMutableArrayArrayArray#,-	copyArrayArray#,-	copyMutableArrayArray#,-	--- * Addr#--- |---	Addr#,-	nullAddr#,-	plusAddr#,-	minusAddr#,-	remAddr#,-	addr2Int#,-	int2Addr#,-	gtAddr#,-	geAddr#,-	eqAddr#,-	neAddr#,-	ltAddr#,-	leAddr#,-	indexCharOffAddr#,-	indexWideCharOffAddr#,-	indexIntOffAddr#,-	indexWordOffAddr#,-	indexAddrOffAddr#,-	indexFloatOffAddr#,-	indexDoubleOffAddr#,-	indexStablePtrOffAddr#,-	indexInt8OffAddr#,-	indexInt16OffAddr#,-	indexInt32OffAddr#,-	indexInt64OffAddr#,-	indexWord8OffAddr#,-	indexWord16OffAddr#,-	indexWord32OffAddr#,-	indexWord64OffAddr#,-	readCharOffAddr#,-	readWideCharOffAddr#,-	readIntOffAddr#,-	readWordOffAddr#,-	readAddrOffAddr#,-	readFloatOffAddr#,-	readDoubleOffAddr#,-	readStablePtrOffAddr#,-	readInt8OffAddr#,-	readInt16OffAddr#,-	readInt32OffAddr#,-	readInt64OffAddr#,-	readWord8OffAddr#,-	readWord16OffAddr#,-	readWord32OffAddr#,-	readWord64OffAddr#,-	writeCharOffAddr#,-	writeWideCharOffAddr#,-	writeIntOffAddr#,-	writeWordOffAddr#,-	writeAddrOffAddr#,-	writeFloatOffAddr#,-	writeDoubleOffAddr#,-	writeStablePtrOffAddr#,-	writeInt8OffAddr#,-	writeInt16OffAddr#,-	writeInt32OffAddr#,-	writeInt64OffAddr#,-	writeWord8OffAddr#,-	writeWord16OffAddr#,-	writeWord32OffAddr#,-	writeWord64OffAddr#,-	--- * Mutable variables--- |Operations on MutVar\#s.---	MutVar#,-	newMutVar#,-	readMutVar#,-	writeMutVar#,-	sameMutVar#,-	atomicModifyMutVar#,-	casMutVar#,-	--- * Exceptions--- |---	catch#,-	raise#,-	raiseIO#,-	maskAsyncExceptions#,-	maskUninterruptible#,-	unmaskAsyncExceptions#,-	getMaskingState#,-	--- * STM-accessible Mutable Variables--- |---	TVar#,-	atomically#,-	retry#,-	catchRetry#,-	catchSTM#,-	check#,-	newTVar#,-	readTVar#,-	readTVarIO#,-	writeTVar#,-	sameTVar#,-	--- * Synchronized Mutable Variables--- |Operations on @MVar\#@s. ---	MVar#,-	newMVar#,-	takeMVar#,-	tryTakeMVar#,-	putMVar#,-	tryPutMVar#,-	readMVar#,-	tryReadMVar#,-	sameMVar#,-	isEmptyMVar#,-	--- * Delay\/wait operations--- |---	delay#,-	waitRead#,-	waitWrite#,-	--- * Concurrency primitives--- |---	State#,-	RealWorld,-	ThreadId#,-	fork#,-	forkOn#,-	killThread#,-	yield#,-	myThreadId#,-	labelThread#,-	isCurrentThreadBound#,-	noDuplicate#,-	threadStatus#,-	--- * Weak pointers--- |---	Weak#,-	mkWeak#,-	mkWeakNoFinalizer#,-	addCFinalizerToWeak#,-	deRefWeak#,-	finalizeWeak#,-	touch#,-	--- * Stable pointers and names--- |---	StablePtr#,-	StableName#,-	makeStablePtr#,-	deRefStablePtr#,-	eqStablePtr#,-	makeStableName#,-	eqStableName#,-	stableNameToInt#,-	--- * Unsafe pointer equality--- |---	reallyUnsafePtrEquality#,-	--- * Parallelism--- |---	par#,-	spark#,-	seq#,-	getSpark#,-	numSparks#,-	parGlobal#,-	parLocal#,-	parAt#,-	parAtAbs#,-	parAtRel#,-	parAtForNow#,-	--- * Tag to enum stuff--- |Convert back and forth between values of enumerated types--- 	and small integers.---	dataToTag#,-	tagToEnum#,-	--- * Bytecode operations--- |Support for the bytecode interpreter and linker.---	BCO#,-	addrToAny#,-	mkApUpd0#,-	newBCO#,-	unpackClosure#,-	getApStackVal#,-	--- * Misc--- |These aren\'t nearly as wired in as Etc...---	getCCSOf#,-	getCurrentCCS#,-	--- * Etc--- |Miscellaneous built-ins---	Proxy#,-	proxy#,-	seq,-	Any,-	AnyK,-	unsafeCoerce#,-	traceEvent#,-	traceMarker#,-	--- * Safe coercions--- |---	coerce,-	Coercible,-	--- * SIMD Vectors--- |Operations on SIMD vectors.---	Int8X16#,-	Int16X8#,-	Int32X4#,-	Int64X2#,-	Int8X32#,-	Int16X16#,-	Int32X8#,-	Int64X4#,-	Int8X64#,-	Int16X32#,-	Int32X16#,-	Int64X8#,-	Word8X16#,-	Word16X8#,-	Word32X4#,-	Word64X2#,-	Word8X32#,-	Word16X16#,-	Word32X8#,-	Word64X4#,-	Word8X64#,-	Word16X32#,-	Word32X16#,-	Word64X8#,-	FloatX4#,-	DoubleX2#,-	FloatX8#,-	DoubleX4#,-	FloatX16#,-	DoubleX8#,-	broadcastInt8X16#,-	broadcastInt16X8#,-	broadcastInt32X4#,-	broadcastInt64X2#,-	broadcastInt8X32#,-	broadcastInt16X16#,-	broadcastInt32X8#,-	broadcastInt64X4#,-	broadcastInt8X64#,-	broadcastInt16X32#,-	broadcastInt32X16#,-	broadcastInt64X8#,-	broadcastWord8X16#,-	broadcastWord16X8#,-	broadcastWord32X4#,-	broadcastWord64X2#,-	broadcastWord8X32#,-	broadcastWord16X16#,-	broadcastWord32X8#,-	broadcastWord64X4#,-	broadcastWord8X64#,-	broadcastWord16X32#,-	broadcastWord32X16#,-	broadcastWord64X8#,-	broadcastFloatX4#,-	broadcastDoubleX2#,-	broadcastFloatX8#,-	broadcastDoubleX4#,-	broadcastFloatX16#,-	broadcastDoubleX8#,-	packInt8X16#,-	packInt16X8#,-	packInt32X4#,-	packInt64X2#,-	packInt8X32#,-	packInt16X16#,-	packInt32X8#,-	packInt64X4#,-	packInt8X64#,-	packInt16X32#,-	packInt32X16#,-	packInt64X8#,-	packWord8X16#,-	packWord16X8#,-	packWord32X4#,-	packWord64X2#,-	packWord8X32#,-	packWord16X16#,-	packWord32X8#,-	packWord64X4#,-	packWord8X64#,-	packWord16X32#,-	packWord32X16#,-	packWord64X8#,-	packFloatX4#,-	packDoubleX2#,-	packFloatX8#,-	packDoubleX4#,-	packFloatX16#,-	packDoubleX8#,-	unpackInt8X16#,-	unpackInt16X8#,-	unpackInt32X4#,-	unpackInt64X2#,-	unpackInt8X32#,-	unpackInt16X16#,-	unpackInt32X8#,-	unpackInt64X4#,-	unpackInt8X64#,-	unpackInt16X32#,-	unpackInt32X16#,-	unpackInt64X8#,-	unpackWord8X16#,-	unpackWord16X8#,-	unpackWord32X4#,-	unpackWord64X2#,-	unpackWord8X32#,-	unpackWord16X16#,-	unpackWord32X8#,-	unpackWord64X4#,-	unpackWord8X64#,-	unpackWord16X32#,-	unpackWord32X16#,-	unpackWord64X8#,-	unpackFloatX4#,-	unpackDoubleX2#,-	unpackFloatX8#,-	unpackDoubleX4#,-	unpackFloatX16#,-	unpackDoubleX8#,-	insertInt8X16#,-	insertInt16X8#,-	insertInt32X4#,-	insertInt64X2#,-	insertInt8X32#,-	insertInt16X16#,-	insertInt32X8#,-	insertInt64X4#,-	insertInt8X64#,-	insertInt16X32#,-	insertInt32X16#,-	insertInt64X8#,-	insertWord8X16#,-	insertWord16X8#,-	insertWord32X4#,-	insertWord64X2#,-	insertWord8X32#,-	insertWord16X16#,-	insertWord32X8#,-	insertWord64X4#,-	insertWord8X64#,-	insertWord16X32#,-	insertWord32X16#,-	insertWord64X8#,-	insertFloatX4#,-	insertDoubleX2#,-	insertFloatX8#,-	insertDoubleX4#,-	insertFloatX16#,-	insertDoubleX8#,-	plusInt8X16#,-	plusInt16X8#,-	plusInt32X4#,-	plusInt64X2#,-	plusInt8X32#,-	plusInt16X16#,-	plusInt32X8#,-	plusInt64X4#,-	plusInt8X64#,-	plusInt16X32#,-	plusInt32X16#,-	plusInt64X8#,-	plusWord8X16#,-	plusWord16X8#,-	plusWord32X4#,-	plusWord64X2#,-	plusWord8X32#,-	plusWord16X16#,-	plusWord32X8#,-	plusWord64X4#,-	plusWord8X64#,-	plusWord16X32#,-	plusWord32X16#,-	plusWord64X8#,-	plusFloatX4#,-	plusDoubleX2#,-	plusFloatX8#,-	plusDoubleX4#,-	plusFloatX16#,-	plusDoubleX8#,-	minusInt8X16#,-	minusInt16X8#,-	minusInt32X4#,-	minusInt64X2#,-	minusInt8X32#,-	minusInt16X16#,-	minusInt32X8#,-	minusInt64X4#,-	minusInt8X64#,-	minusInt16X32#,-	minusInt32X16#,-	minusInt64X8#,-	minusWord8X16#,-	minusWord16X8#,-	minusWord32X4#,-	minusWord64X2#,-	minusWord8X32#,-	minusWord16X16#,-	minusWord32X8#,-	minusWord64X4#,-	minusWord8X64#,-	minusWord16X32#,-	minusWord32X16#,-	minusWord64X8#,-	minusFloatX4#,-	minusDoubleX2#,-	minusFloatX8#,-	minusDoubleX4#,-	minusFloatX16#,-	minusDoubleX8#,-	timesInt8X16#,-	timesInt16X8#,-	timesInt32X4#,-	timesInt64X2#,-	timesInt8X32#,-	timesInt16X16#,-	timesInt32X8#,-	timesInt64X4#,-	timesInt8X64#,-	timesInt16X32#,-	timesInt32X16#,-	timesInt64X8#,-	timesWord8X16#,-	timesWord16X8#,-	timesWord32X4#,-	timesWord64X2#,-	timesWord8X32#,-	timesWord16X16#,-	timesWord32X8#,-	timesWord64X4#,-	timesWord8X64#,-	timesWord16X32#,-	timesWord32X16#,-	timesWord64X8#,-	timesFloatX4#,-	timesDoubleX2#,-	timesFloatX8#,-	timesDoubleX4#,-	timesFloatX16#,-	timesDoubleX8#,-	divideFloatX4#,-	divideDoubleX2#,-	divideFloatX8#,-	divideDoubleX4#,-	divideFloatX16#,-	divideDoubleX8#,-	quotInt8X16#,-	quotInt16X8#,-	quotInt32X4#,-	quotInt64X2#,-	quotInt8X32#,-	quotInt16X16#,-	quotInt32X8#,-	quotInt64X4#,-	quotInt8X64#,-	quotInt16X32#,-	quotInt32X16#,-	quotInt64X8#,-	quotWord8X16#,-	quotWord16X8#,-	quotWord32X4#,-	quotWord64X2#,-	quotWord8X32#,-	quotWord16X16#,-	quotWord32X8#,-	quotWord64X4#,-	quotWord8X64#,-	quotWord16X32#,-	quotWord32X16#,-	quotWord64X8#,-	remInt8X16#,-	remInt16X8#,-	remInt32X4#,-	remInt64X2#,-	remInt8X32#,-	remInt16X16#,-	remInt32X8#,-	remInt64X4#,-	remInt8X64#,-	remInt16X32#,-	remInt32X16#,-	remInt64X8#,-	remWord8X16#,-	remWord16X8#,-	remWord32X4#,-	remWord64X2#,-	remWord8X32#,-	remWord16X16#,-	remWord32X8#,-	remWord64X4#,-	remWord8X64#,-	remWord16X32#,-	remWord32X16#,-	remWord64X8#,-	negateInt8X16#,-	negateInt16X8#,-	negateInt32X4#,-	negateInt64X2#,-	negateInt8X32#,-	negateInt16X16#,-	negateInt32X8#,-	negateInt64X4#,-	negateInt8X64#,-	negateInt16X32#,-	negateInt32X16#,-	negateInt64X8#,-	negateFloatX4#,-	negateDoubleX2#,-	negateFloatX8#,-	negateDoubleX4#,-	negateFloatX16#,-	negateDoubleX8#,-	indexInt8X16Array#,-	indexInt16X8Array#,-	indexInt32X4Array#,-	indexInt64X2Array#,-	indexInt8X32Array#,-	indexInt16X16Array#,-	indexInt32X8Array#,-	indexInt64X4Array#,-	indexInt8X64Array#,-	indexInt16X32Array#,-	indexInt32X16Array#,-	indexInt64X8Array#,-	indexWord8X16Array#,-	indexWord16X8Array#,-	indexWord32X4Array#,-	indexWord64X2Array#,-	indexWord8X32Array#,-	indexWord16X16Array#,-	indexWord32X8Array#,-	indexWord64X4Array#,-	indexWord8X64Array#,-	indexWord16X32Array#,-	indexWord32X16Array#,-	indexWord64X8Array#,-	indexFloatX4Array#,-	indexDoubleX2Array#,-	indexFloatX8Array#,-	indexDoubleX4Array#,-	indexFloatX16Array#,-	indexDoubleX8Array#,-	readInt8X16Array#,-	readInt16X8Array#,-	readInt32X4Array#,-	readInt64X2Array#,-	readInt8X32Array#,-	readInt16X16Array#,-	readInt32X8Array#,-	readInt64X4Array#,-	readInt8X64Array#,-	readInt16X32Array#,-	readInt32X16Array#,-	readInt64X8Array#,-	readWord8X16Array#,-	readWord16X8Array#,-	readWord32X4Array#,-	readWord64X2Array#,-	readWord8X32Array#,-	readWord16X16Array#,-	readWord32X8Array#,-	readWord64X4Array#,-	readWord8X64Array#,-	readWord16X32Array#,-	readWord32X16Array#,-	readWord64X8Array#,-	readFloatX4Array#,-	readDoubleX2Array#,-	readFloatX8Array#,-	readDoubleX4Array#,-	readFloatX16Array#,-	readDoubleX8Array#,-	writeInt8X16Array#,-	writeInt16X8Array#,-	writeInt32X4Array#,-	writeInt64X2Array#,-	writeInt8X32Array#,-	writeInt16X16Array#,-	writeInt32X8Array#,-	writeInt64X4Array#,-	writeInt8X64Array#,-	writeInt16X32Array#,-	writeInt32X16Array#,-	writeInt64X8Array#,-	writeWord8X16Array#,-	writeWord16X8Array#,-	writeWord32X4Array#,-	writeWord64X2Array#,-	writeWord8X32Array#,-	writeWord16X16Array#,-	writeWord32X8Array#,-	writeWord64X4Array#,-	writeWord8X64Array#,-	writeWord16X32Array#,-	writeWord32X16Array#,-	writeWord64X8Array#,-	writeFloatX4Array#,-	writeDoubleX2Array#,-	writeFloatX8Array#,-	writeDoubleX4Array#,-	writeFloatX16Array#,-	writeDoubleX8Array#,-	indexInt8X16OffAddr#,-	indexInt16X8OffAddr#,-	indexInt32X4OffAddr#,-	indexInt64X2OffAddr#,-	indexInt8X32OffAddr#,-	indexInt16X16OffAddr#,-	indexInt32X8OffAddr#,-	indexInt64X4OffAddr#,-	indexInt8X64OffAddr#,-	indexInt16X32OffAddr#,-	indexInt32X16OffAddr#,-	indexInt64X8OffAddr#,-	indexWord8X16OffAddr#,-	indexWord16X8OffAddr#,-	indexWord32X4OffAddr#,-	indexWord64X2OffAddr#,-	indexWord8X32OffAddr#,-	indexWord16X16OffAddr#,-	indexWord32X8OffAddr#,-	indexWord64X4OffAddr#,-	indexWord8X64OffAddr#,-	indexWord16X32OffAddr#,-	indexWord32X16OffAddr#,-	indexWord64X8OffAddr#,-	indexFloatX4OffAddr#,-	indexDoubleX2OffAddr#,-	indexFloatX8OffAddr#,-	indexDoubleX4OffAddr#,-	indexFloatX16OffAddr#,-	indexDoubleX8OffAddr#,-	readInt8X16OffAddr#,-	readInt16X8OffAddr#,-	readInt32X4OffAddr#,-	readInt64X2OffAddr#,-	readInt8X32OffAddr#,-	readInt16X16OffAddr#,-	readInt32X8OffAddr#,-	readInt64X4OffAddr#,-	readInt8X64OffAddr#,-	readInt16X32OffAddr#,-	readInt32X16OffAddr#,-	readInt64X8OffAddr#,-	readWord8X16OffAddr#,-	readWord16X8OffAddr#,-	readWord32X4OffAddr#,-	readWord64X2OffAddr#,-	readWord8X32OffAddr#,-	readWord16X16OffAddr#,-	readWord32X8OffAddr#,-	readWord64X4OffAddr#,-	readWord8X64OffAddr#,-	readWord16X32OffAddr#,-	readWord32X16OffAddr#,-	readWord64X8OffAddr#,-	readFloatX4OffAddr#,-	readDoubleX2OffAddr#,-	readFloatX8OffAddr#,-	readDoubleX4OffAddr#,-	readFloatX16OffAddr#,-	readDoubleX8OffAddr#,-	writeInt8X16OffAddr#,-	writeInt16X8OffAddr#,-	writeInt32X4OffAddr#,-	writeInt64X2OffAddr#,-	writeInt8X32OffAddr#,-	writeInt16X16OffAddr#,-	writeInt32X8OffAddr#,-	writeInt64X4OffAddr#,-	writeInt8X64OffAddr#,-	writeInt16X32OffAddr#,-	writeInt32X16OffAddr#,-	writeInt64X8OffAddr#,-	writeWord8X16OffAddr#,-	writeWord16X8OffAddr#,-	writeWord32X4OffAddr#,-	writeWord64X2OffAddr#,-	writeWord8X32OffAddr#,-	writeWord16X16OffAddr#,-	writeWord32X8OffAddr#,-	writeWord64X4OffAddr#,-	writeWord8X64OffAddr#,-	writeWord16X32OffAddr#,-	writeWord32X16OffAddr#,-	writeWord64X8OffAddr#,-	writeFloatX4OffAddr#,-	writeDoubleX2OffAddr#,-	writeFloatX8OffAddr#,-	writeDoubleX4OffAddr#,-	writeFloatX16OffAddr#,-	writeDoubleX8OffAddr#,-	indexInt8ArrayAsInt8X16#,-	indexInt16ArrayAsInt16X8#,-	indexInt32ArrayAsInt32X4#,-	indexInt64ArrayAsInt64X2#,-	indexInt8ArrayAsInt8X32#,-	indexInt16ArrayAsInt16X16#,-	indexInt32ArrayAsInt32X8#,-	indexInt64ArrayAsInt64X4#,-	indexInt8ArrayAsInt8X64#,-	indexInt16ArrayAsInt16X32#,-	indexInt32ArrayAsInt32X16#,-	indexInt64ArrayAsInt64X8#,-	indexWord8ArrayAsWord8X16#,-	indexWord16ArrayAsWord16X8#,-	indexWord32ArrayAsWord32X4#,-	indexWord64ArrayAsWord64X2#,-	indexWord8ArrayAsWord8X32#,-	indexWord16ArrayAsWord16X16#,-	indexWord32ArrayAsWord32X8#,-	indexWord64ArrayAsWord64X4#,-	indexWord8ArrayAsWord8X64#,-	indexWord16ArrayAsWord16X32#,-	indexWord32ArrayAsWord32X16#,-	indexWord64ArrayAsWord64X8#,-	indexFloatArrayAsFloatX4#,-	indexDoubleArrayAsDoubleX2#,-	indexFloatArrayAsFloatX8#,-	indexDoubleArrayAsDoubleX4#,-	indexFloatArrayAsFloatX16#,-	indexDoubleArrayAsDoubleX8#,-	readInt8ArrayAsInt8X16#,-	readInt16ArrayAsInt16X8#,-	readInt32ArrayAsInt32X4#,-	readInt64ArrayAsInt64X2#,-	readInt8ArrayAsInt8X32#,-	readInt16ArrayAsInt16X16#,-	readInt32ArrayAsInt32X8#,-	readInt64ArrayAsInt64X4#,-	readInt8ArrayAsInt8X64#,-	readInt16ArrayAsInt16X32#,-	readInt32ArrayAsInt32X16#,-	readInt64ArrayAsInt64X8#,-	readWord8ArrayAsWord8X16#,-	readWord16ArrayAsWord16X8#,-	readWord32ArrayAsWord32X4#,-	readWord64ArrayAsWord64X2#,-	readWord8ArrayAsWord8X32#,-	readWord16ArrayAsWord16X16#,-	readWord32ArrayAsWord32X8#,-	readWord64ArrayAsWord64X4#,-	readWord8ArrayAsWord8X64#,-	readWord16ArrayAsWord16X32#,-	readWord32ArrayAsWord32X16#,-	readWord64ArrayAsWord64X8#,-	readFloatArrayAsFloatX4#,-	readDoubleArrayAsDoubleX2#,-	readFloatArrayAsFloatX8#,-	readDoubleArrayAsDoubleX4#,-	readFloatArrayAsFloatX16#,-	readDoubleArrayAsDoubleX8#,-	writeInt8ArrayAsInt8X16#,-	writeInt16ArrayAsInt16X8#,-	writeInt32ArrayAsInt32X4#,-	writeInt64ArrayAsInt64X2#,-	writeInt8ArrayAsInt8X32#,-	writeInt16ArrayAsInt16X16#,-	writeInt32ArrayAsInt32X8#,-	writeInt64ArrayAsInt64X4#,-	writeInt8ArrayAsInt8X64#,-	writeInt16ArrayAsInt16X32#,-	writeInt32ArrayAsInt32X16#,-	writeInt64ArrayAsInt64X8#,-	writeWord8ArrayAsWord8X16#,-	writeWord16ArrayAsWord16X8#,-	writeWord32ArrayAsWord32X4#,-	writeWord64ArrayAsWord64X2#,-	writeWord8ArrayAsWord8X32#,-	writeWord16ArrayAsWord16X16#,-	writeWord32ArrayAsWord32X8#,-	writeWord64ArrayAsWord64X4#,-	writeWord8ArrayAsWord8X64#,-	writeWord16ArrayAsWord16X32#,-	writeWord32ArrayAsWord32X16#,-	writeWord64ArrayAsWord64X8#,-	writeFloatArrayAsFloatX4#,-	writeDoubleArrayAsDoubleX2#,-	writeFloatArrayAsFloatX8#,-	writeDoubleArrayAsDoubleX4#,-	writeFloatArrayAsFloatX16#,-	writeDoubleArrayAsDoubleX8#,-	indexInt8OffAddrAsInt8X16#,-	indexInt16OffAddrAsInt16X8#,-	indexInt32OffAddrAsInt32X4#,-	indexInt64OffAddrAsInt64X2#,-	indexInt8OffAddrAsInt8X32#,-	indexInt16OffAddrAsInt16X16#,-	indexInt32OffAddrAsInt32X8#,-	indexInt64OffAddrAsInt64X4#,-	indexInt8OffAddrAsInt8X64#,-	indexInt16OffAddrAsInt16X32#,-	indexInt32OffAddrAsInt32X16#,-	indexInt64OffAddrAsInt64X8#,-	indexWord8OffAddrAsWord8X16#,-	indexWord16OffAddrAsWord16X8#,-	indexWord32OffAddrAsWord32X4#,-	indexWord64OffAddrAsWord64X2#,-	indexWord8OffAddrAsWord8X32#,-	indexWord16OffAddrAsWord16X16#,-	indexWord32OffAddrAsWord32X8#,-	indexWord64OffAddrAsWord64X4#,-	indexWord8OffAddrAsWord8X64#,-	indexWord16OffAddrAsWord16X32#,-	indexWord32OffAddrAsWord32X16#,-	indexWord64OffAddrAsWord64X8#,-	indexFloatOffAddrAsFloatX4#,-	indexDoubleOffAddrAsDoubleX2#,-	indexFloatOffAddrAsFloatX8#,-	indexDoubleOffAddrAsDoubleX4#,-	indexFloatOffAddrAsFloatX16#,-	indexDoubleOffAddrAsDoubleX8#,-	readInt8OffAddrAsInt8X16#,-	readInt16OffAddrAsInt16X8#,-	readInt32OffAddrAsInt32X4#,-	readInt64OffAddrAsInt64X2#,-	readInt8OffAddrAsInt8X32#,-	readInt16OffAddrAsInt16X16#,-	readInt32OffAddrAsInt32X8#,-	readInt64OffAddrAsInt64X4#,-	readInt8OffAddrAsInt8X64#,-	readInt16OffAddrAsInt16X32#,-	readInt32OffAddrAsInt32X16#,-	readInt64OffAddrAsInt64X8#,-	readWord8OffAddrAsWord8X16#,-	readWord16OffAddrAsWord16X8#,-	readWord32OffAddrAsWord32X4#,-	readWord64OffAddrAsWord64X2#,-	readWord8OffAddrAsWord8X32#,-	readWord16OffAddrAsWord16X16#,-	readWord32OffAddrAsWord32X8#,-	readWord64OffAddrAsWord64X4#,-	readWord8OffAddrAsWord8X64#,-	readWord16OffAddrAsWord16X32#,-	readWord32OffAddrAsWord32X16#,-	readWord64OffAddrAsWord64X8#,-	readFloatOffAddrAsFloatX4#,-	readDoubleOffAddrAsDoubleX2#,-	readFloatOffAddrAsFloatX8#,-	readDoubleOffAddrAsDoubleX4#,-	readFloatOffAddrAsFloatX16#,-	readDoubleOffAddrAsDoubleX8#,-	writeInt8OffAddrAsInt8X16#,-	writeInt16OffAddrAsInt16X8#,-	writeInt32OffAddrAsInt32X4#,-	writeInt64OffAddrAsInt64X2#,-	writeInt8OffAddrAsInt8X32#,-	writeInt16OffAddrAsInt16X16#,-	writeInt32OffAddrAsInt32X8#,-	writeInt64OffAddrAsInt64X4#,-	writeInt8OffAddrAsInt8X64#,-	writeInt16OffAddrAsInt16X32#,-	writeInt32OffAddrAsInt32X16#,-	writeInt64OffAddrAsInt64X8#,-	writeWord8OffAddrAsWord8X16#,-	writeWord16OffAddrAsWord16X8#,-	writeWord32OffAddrAsWord32X4#,-	writeWord64OffAddrAsWord64X2#,-	writeWord8OffAddrAsWord8X32#,-	writeWord16OffAddrAsWord16X16#,-	writeWord32OffAddrAsWord32X8#,-	writeWord64OffAddrAsWord64X4#,-	writeWord8OffAddrAsWord8X64#,-	writeWord16OffAddrAsWord16X32#,-	writeWord32OffAddrAsWord32X16#,-	writeWord64OffAddrAsWord64X8#,-	writeFloatOffAddrAsFloatX4#,-	writeDoubleOffAddrAsDoubleX2#,-	writeFloatOffAddrAsFloatX8#,-	writeDoubleOffAddrAsDoubleX4#,-	writeFloatOffAddrAsFloatX16#,-	writeDoubleOffAddrAsDoubleX8#,-	--- * Prefetch--- |Prefetch operations: Note how every prefetch operation has a name---   with the pattern prefetch*N#, where N is either 0,1,2, or 3.--- ---   This suffix number, N, is the \"locality level\" of the prefetch, following the---   convention in GCC and other compilers.---   Higher locality numbers correspond to the memory being loaded in more---   levels of the cpu cache, and being retained after initial use. The naming---   convention follows the naming convention of the prefetch intrinsic found---   in the GCC and Clang C compilers.--- ---   On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic---   with locality level N. The code generated by LLVM is target architecture---   dependent, but should agree with the GHC NCG on x86 systems.--- ---   On the Sparc and PPC native backends, prefetch*N is a No-Op.--- ---   On the x86 NCG, N=0 will generate prefetchNTA,---   N=1 generates prefetcht2, N=2 generates prefetcht1, and---   N=3 generates prefetcht0.--- ---   For streaming workloads, the prefetch*0 operations are recommended.---   For workloads which do many reads or writes to a memory location in a short period of time,---   prefetch*3 operations are recommended.--- ---   For further reading about prefetch and associated systems performance optimization,---   the instruction set and optimization manuals by Intel and other CPU vendors are---   excellent starting place.--- --- ---   The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is---   especially a helpful read, even if your software is meant for other CPU---   architectures or vendor hardware. The manual can be found at---   http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html .--- ---   The @prefetchMutableByteArray@ family of operations has the order of operations---   determined by passing around the @State#@ token.--- ---   For the @prefetchByteArray@---   and @prefetchAddr@ families of operations, consider the following example:--- ---   @let a1 = prefetchByteArray2# a n in ...a1... @--- ---   In the above fragement, @a@ is the input variable for the prefetch---   and @a1 == a@ will be true. To ensure that the prefetch is not treated as deadcode,---   the body of the let should only use @a1@ and NOT @a@. The same principle---   applies for uses of prefetch in a loop.--- ---   ---	prefetchByteArray3#,-	prefetchMutableByteArray3#,-	prefetchAddr3#,-	prefetchByteArray2#,-	prefetchMutableByteArray2#,-	prefetchAddr2#,-	prefetchByteArray1#,-	prefetchMutableByteArray1#,-	prefetchAddr1#,-	prefetchByteArray0#,-	prefetchMutableByteArray0#,-	prefetchAddr0#,-) where--{--has_side_effects = False-out_of_line = False-can_fail = False-commutable = False-code_size = {  primOpCodeSizeDefault }-strictness = {  \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }-fixity = Nothing-llvm_only = False---}--data Char#--gtChar# :: Char# -> Char# -> Int#-gtChar# = let x = x in x--geChar# :: Char# -> Char# -> Int#-geChar# = let x = x in x--eqChar# :: Char# -> Char# -> Int#-eqChar# = let x = x in x--neChar# :: Char# -> Char# -> Int#-neChar# = let x = x in x--ltChar# :: Char# -> Char# -> Int#-ltChar# = let x = x in x--leChar# :: Char# -> Char# -> Int#-leChar# = let x = x in x--ord# :: Char# -> Int#-ord# = let x = x in x--data Int#--infixl 6 +#-(+#) :: Int# -> Int# -> Int#-(+#) = let x = x in x--infixl 6 -#-(-#) :: Int# -> Int# -> Int#-(-#) = let x = x in x---- |Low word of signed integer multiply.--infixl 7 *#-(*#) :: Int# -> Int# -> Int#-(*#) = let x = x in x---- |Return non-zero if there is any possibility that the upper word of a---     signed integer multiply might contain useful information.  Return---     zero only if you are completely sure that no overflow can occur.---     On a 32-bit platform, the recommmended implementation is to do a---     32 x 32 -> 64 signed multiply, and subtract result[63:32] from---     (result[31] >>signed 31).  If this is zero, meaning that the---     upper word is merely a sign extension of the lower one, no---     overflow can occur.--- ---     On a 64-bit platform it is not always possible to---     acquire the top 64 bits of the result.  Therefore, a recommended---     implementation is to take the absolute value of both operands, and---     return 0 iff bits[63:31] of them are zero, since that means that their---     magnitudes fit within 31 bits, so the magnitude of the product must fit---     into 62 bits.--- ---     If in doubt, return non-zero, but do make an effort to create the---     correct answer for small args, since otherwise the performance of---     @(*) :: Integer -> Integer -> Integer@ will be poor.---    --mulIntMayOflo# :: Int# -> Int# -> Int#-mulIntMayOflo# = let x = x in x---- |Rounds towards zero.--quotInt# :: Int# -> Int# -> Int#-quotInt# = let x = x in x---- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@.--remInt# :: Int# -> Int# -> Int#-remInt# = let x = x in x---- |Rounds towards zero.--quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)-quotRemInt# = let x = x in x--andI# :: Int# -> Int# -> Int#-andI# = let x = x in x--orI# :: Int# -> Int# -> Int#-orI# = let x = x in x--xorI# :: Int# -> Int# -> Int#-xorI# = let x = x in x--notI# :: Int# -> Int#-notI# = let x = x in x--negateInt# :: Int# -> Int#-negateInt# = let x = x in x---- |Add with carry.  First member of result is (wrapped) sum;---           second member is 0 iff no overflow occured.--addIntC# :: Int# -> Int# -> (# Int#,Int# #)-addIntC# = let x = x in x---- |Subtract with carry.  First member of result is (wrapped) difference;---           second member is 0 iff no overflow occured.--subIntC# :: Int# -> Int# -> (# Int#,Int# #)-subIntC# = let x = x in x--infix 4 >#-(>#) :: Int# -> Int# -> Int#-(>#) = let x = x in x--infix 4 >=#-(>=#) :: Int# -> Int# -> Int#-(>=#) = let x = x in x--infix 4 ==#-(==#) :: Int# -> Int# -> Int#-(==#) = let x = x in x--infix 4 /=#-(/=#) :: Int# -> Int# -> Int#-(/=#) = let x = x in x--infix 4 <#-(<#) :: Int# -> Int# -> Int#-(<#) = let x = x in x--infix 4 <=#-(<=#) :: Int# -> Int# -> Int#-(<=#) = let x = x in x--chr# :: Int# -> Char#-chr# = let x = x in x--int2Word# :: Int# -> Word#-int2Word# = let x = x in x--int2Float# :: Int# -> Float#-int2Float# = let x = x in x--int2Double# :: Int# -> Double#-int2Double# = let x = x in x--word2Float# :: Word# -> Float#-word2Float# = let x = x in x--word2Double# :: Word# -> Double#-word2Double# = let x = x in x---- |Shift left.  Result undefined if shift amount is not---           in the range 0 to word size - 1 inclusive.--uncheckedIShiftL# :: Int# -> Int# -> Int#-uncheckedIShiftL# = let x = x in x---- |Shift right arithmetic.  Result undefined if shift amount is not---           in the range 0 to word size - 1 inclusive.--uncheckedIShiftRA# :: Int# -> Int# -> Int#-uncheckedIShiftRA# = let x = x in x---- |Shift right logical.  Result undefined if shift amount is not---           in the range 0 to word size - 1 inclusive.--uncheckedIShiftRL# :: Int# -> Int# -> Int#-uncheckedIShiftRL# = let x = x in x--data Word#--plusWord# :: Word# -> Word# -> Word#-plusWord# = let x = x in x--plusWord2# :: Word# -> Word# -> (# Word#,Word# #)-plusWord2# = let x = x in x--minusWord# :: Word# -> Word# -> Word#-minusWord# = let x = x in x--timesWord# :: Word# -> Word# -> Word#-timesWord# = let x = x in x--timesWord2# :: Word# -> Word# -> (# Word#,Word# #)-timesWord2# = let x = x in x--quotWord# :: Word# -> Word# -> Word#-quotWord# = let x = x in x--remWord# :: Word# -> Word# -> Word#-remWord# = let x = x in x--quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)-quotRemWord# = let x = x in x--quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)-quotRemWord2# = let x = x in x--and# :: Word# -> Word# -> Word#-and# = let x = x in x--or# :: Word# -> Word# -> Word#-or# = let x = x in x--xor# :: Word# -> Word# -> Word#-xor# = let x = x in x--not# :: Word# -> Word#-not# = let x = x in x---- |Shift left logical.   Result undefined if shift amount is not---           in the range 0 to word size - 1 inclusive.--uncheckedShiftL# :: Word# -> Int# -> Word#-uncheckedShiftL# = let x = x in x---- |Shift right logical.   Result undefined if shift  amount is not---           in the range 0 to word size - 1 inclusive.--uncheckedShiftRL# :: Word# -> Int# -> Word#-uncheckedShiftRL# = let x = x in x--word2Int# :: Word# -> Int#-word2Int# = let x = x in x--gtWord# :: Word# -> Word# -> Int#-gtWord# = let x = x in x--geWord# :: Word# -> Word# -> Int#-geWord# = let x = x in x--eqWord# :: Word# -> Word# -> Int#-eqWord# = let x = x in x--neWord# :: Word# -> Word# -> Int#-neWord# = let x = x in x--ltWord# :: Word# -> Word# -> Int#-ltWord# = let x = x in x--leWord# :: Word# -> Word# -> Int#-leWord# = let x = x in x---- |Count the number of set bits in the lower 8 bits of a word.--popCnt8# :: Word# -> Word#-popCnt8# = let x = x in x---- |Count the number of set bits in the lower 16 bits of a word.--popCnt16# :: Word# -> Word#-popCnt16# = let x = x in x---- |Count the number of set bits in the lower 32 bits of a word.--popCnt32# :: Word# -> Word#-popCnt32# = let x = x in x---- |Count the number of set bits in a 64-bit word.--popCnt64# :: Word# -> Word#-popCnt64# = let x = x in x---- |Count the number of set bits in a word.--popCnt# :: Word# -> Word#-popCnt# = let x = x in x---- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. --byteSwap16# :: Word# -> Word#-byteSwap16# = let x = x in x---- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. --byteSwap32# :: Word# -> Word#-byteSwap32# = let x = x in x---- |Swap bytes in a 64 bits of a word.--byteSwap64# :: Word# -> Word#-byteSwap64# = let x = x in x---- |Swap bytes in a word.--byteSwap# :: Word# -> Word#-byteSwap# = let x = x in x--narrow8Int# :: Int# -> Int#-narrow8Int# = let x = x in x--narrow16Int# :: Int# -> Int#-narrow16Int# = let x = x in x--narrow32Int# :: Int# -> Int#-narrow32Int# = let x = x in x--narrow8Word# :: Word# -> Word#-narrow8Word# = let x = x in x--narrow16Word# :: Word# -> Word#-narrow16Word# = let x = x in x--narrow32Word# :: Word# -> Word#-narrow32Word# = let x = x in x--data Double#--infix 4 >##-(>##) :: Double# -> Double# -> Int#-(>##) = let x = x in x--infix 4 >=##-(>=##) :: Double# -> Double# -> Int#-(>=##) = let x = x in x--infix 4 ==##-(==##) :: Double# -> Double# -> Int#-(==##) = let x = x in x--infix 4 /=##-(/=##) :: Double# -> Double# -> Int#-(/=##) = let x = x in x--infix 4 <##-(<##) :: Double# -> Double# -> Int#-(<##) = let x = x in x--infix 4 <=##-(<=##) :: Double# -> Double# -> Int#-(<=##) = let x = x in x--infixl 6 +##-(+##) :: Double# -> Double# -> Double#-(+##) = let x = x in x--infixl 6 -##-(-##) :: Double# -> Double# -> Double#-(-##) = let x = x in x--infixl 7 *##-(*##) :: Double# -> Double# -> Double#-(*##) = let x = x in x--infixl 7 /##-(/##) :: Double# -> Double# -> Double#-(/##) = let x = x in x--negateDouble# :: Double# -> Double#-negateDouble# = let x = x in x---- |Truncates a @Double#@ value to the nearest @Int#@.---     Results are undefined if the truncation if truncation yields---     a value outside the range of @Int#@.--double2Int# :: Double# -> Int#-double2Int# = let x = x in x--double2Float# :: Double# -> Float#-double2Float# = let x = x in x--expDouble# :: Double# -> Double#-expDouble# = let x = x in x--logDouble# :: Double# -> Double#-logDouble# = let x = x in x--sqrtDouble# :: Double# -> Double#-sqrtDouble# = let x = x in x--sinDouble# :: Double# -> Double#-sinDouble# = let x = x in x--cosDouble# :: Double# -> Double#-cosDouble# = let x = x in x--tanDouble# :: Double# -> Double#-tanDouble# = let x = x in x--asinDouble# :: Double# -> Double#-asinDouble# = let x = x in x--acosDouble# :: Double# -> Double#-acosDouble# = let x = x in x--atanDouble# :: Double# -> Double#-atanDouble# = let x = x in x--sinhDouble# :: Double# -> Double#-sinhDouble# = let x = x in x--coshDouble# :: Double# -> Double#-coshDouble# = let x = x in x--tanhDouble# :: Double# -> Double#-tanhDouble# = let x = x in x---- |Exponentiation.--(**##) :: Double# -> Double# -> Double#-(**##) = let x = x in x---- |Convert to integer.---     First component of the result is -1 or 1, indicating the sign of the---     mantissa. The next two are the high and low 32 bits of the mantissa---     respectively, and the last is the exponent.--decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)-decodeDouble_2Int# = let x = x in x--data Float#--gtFloat# :: Float# -> Float# -> Int#-gtFloat# = let x = x in x--geFloat# :: Float# -> Float# -> Int#-geFloat# = let x = x in x--eqFloat# :: Float# -> Float# -> Int#-eqFloat# = let x = x in x--neFloat# :: Float# -> Float# -> Int#-neFloat# = let x = x in x--ltFloat# :: Float# -> Float# -> Int#-ltFloat# = let x = x in x--leFloat# :: Float# -> Float# -> Int#-leFloat# = let x = x in x--plusFloat# :: Float# -> Float# -> Float#-plusFloat# = let x = x in x--minusFloat# :: Float# -> Float# -> Float#-minusFloat# = let x = x in x--timesFloat# :: Float# -> Float# -> Float#-timesFloat# = let x = x in x--divideFloat# :: Float# -> Float# -> Float#-divideFloat# = let x = x in x--negateFloat# :: Float# -> Float#-negateFloat# = let x = x in x---- |Truncates a @Float#@ value to the nearest @Int#@.---     Results are undefined if the truncation if truncation yields---     a value outside the range of @Int#@.--float2Int# :: Float# -> Int#-float2Int# = let x = x in x--expFloat# :: Float# -> Float#-expFloat# = let x = x in x--logFloat# :: Float# -> Float#-logFloat# = let x = x in x--sqrtFloat# :: Float# -> Float#-sqrtFloat# = let x = x in x--sinFloat# :: Float# -> Float#-sinFloat# = let x = x in x--cosFloat# :: Float# -> Float#-cosFloat# = let x = x in x--tanFloat# :: Float# -> Float#-tanFloat# = let x = x in x--asinFloat# :: Float# -> Float#-asinFloat# = let x = x in x--acosFloat# :: Float# -> Float#-acosFloat# = let x = x in x--atanFloat# :: Float# -> Float#-atanFloat# = let x = x in x--sinhFloat# :: Float# -> Float#-sinhFloat# = let x = x in x--coshFloat# :: Float# -> Float#-coshFloat# = let x = x in x--tanhFloat# :: Float# -> Float#-tanhFloat# = let x = x in x--powerFloat# :: Float# -> Float# -> Float#-powerFloat# = let x = x in x--float2Double# :: Float# -> Double#-float2Double# = let x = x in x---- |Convert to integers.---     First @Int\#@ in result is the mantissa; second is the exponent.--decodeFloat_Int# :: Float# -> (# Int#,Int# #)-decodeFloat_Int# = let x = x in x--data Array# a--data MutableArray# s a---- |Create a new mutable array with the specified number of elements,---     in the specified state thread,---     with each element containing the specified initial value.--newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)-newArray# = let x = x in x--sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#-sameMutableArray# = let x = x in x---- |Read from specified index of mutable array. Result is not yet evaluated.--readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)-readArray# = let x = x in x---- |Write to specified index of mutable array.--writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s-writeArray# = let x = x in x---- |Return the number of elements in the array.--sizeofArray# :: Array# a -> Int#-sizeofArray# = let x = x in x---- |Return the number of elements in the array.--sizeofMutableArray# :: MutableArray# s a -> Int#-sizeofMutableArray# = let x = x in x---- |Read from specified index of immutable array. Result is packaged into---     an unboxed singleton; the result itself is not yet evaluated.--indexArray# :: Array# a -> Int# -> (# a #)-indexArray# = let x = x in x---- |Make a mutable array immutable, without copying.--unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)-unsafeFreezeArray# = let x = x in x---- |Make an immutable array mutable, without copying.--unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)-unsafeThawArray# = let x = x in x---- |Copy a range of the Array# to the specified region in the MutableArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.---    The two arrays must not be the same array in different states, but this is not checked either.--copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyArray# = let x = x in x---- |Copy a range of the first MutableArray# to the specified region in the second MutableArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyMutableArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided Array#.---    The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.--cloneArray# :: Array# a -> Int# -> Int# -> Array# a-cloneArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided Array#.---    The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.--cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-cloneMutableArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.---    The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.--freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)-freezeArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.---    The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.--thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-thawArray# = let x = x in x---- |Unsafe, machine-level atomic compare and swap on an element within an Array.--casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)-casArray# = let x = x in x--data ByteArray#--data MutableByteArray# s---- |Create a new mutable byte array of specified size (in bytes), in---     the specified state thread.--newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newByteArray# = let x = x in x---- |Create a mutable byte array that the GC guarantees not to move.--newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newPinnedByteArray# = let x = x in x---- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.--newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-newAlignedPinnedByteArray# = let x = x in x---- |Intended for use with pinned arrays; otherwise very unsafe!--byteArrayContents# :: ByteArray# -> Addr#-byteArrayContents# = let x = x in x--sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#-sameMutableByteArray# = let x = x in x---- |Make a mutable byte array immutable, without copying.--unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)-unsafeFreezeByteArray# = let x = x in x---- |Return the size of the array in bytes.--sizeofByteArray# :: ByteArray# -> Int#-sizeofByteArray# = let x = x in x---- |Return the size of the array in bytes.--sizeofMutableByteArray# :: MutableByteArray# s -> Int#-sizeofMutableByteArray# = let x = x in x---- |Read 8-bit character; offset in bytes.--indexCharArray# :: ByteArray# -> Int# -> Char#-indexCharArray# = let x = x in x---- |Read 31-bit character; offset in 4-byte words.--indexWideCharArray# :: ByteArray# -> Int# -> Char#-indexWideCharArray# = let x = x in x--indexIntArray# :: ByteArray# -> Int# -> Int#-indexIntArray# = let x = x in x--indexWordArray# :: ByteArray# -> Int# -> Word#-indexWordArray# = let x = x in x--indexAddrArray# :: ByteArray# -> Int# -> Addr#-indexAddrArray# = let x = x in x--indexFloatArray# :: ByteArray# -> Int# -> Float#-indexFloatArray# = let x = x in x--indexDoubleArray# :: ByteArray# -> Int# -> Double#-indexDoubleArray# = let x = x in x--indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a-indexStablePtrArray# = let x = x in x--indexInt8Array# :: ByteArray# -> Int# -> Int#-indexInt8Array# = let x = x in x--indexInt16Array# :: ByteArray# -> Int# -> Int#-indexInt16Array# = let x = x in x--indexInt32Array# :: ByteArray# -> Int# -> Int#-indexInt32Array# = let x = x in x--indexInt64Array# :: ByteArray# -> Int# -> Int#-indexInt64Array# = let x = x in x--indexWord8Array# :: ByteArray# -> Int# -> Word#-indexWord8Array# = let x = x in x--indexWord16Array# :: ByteArray# -> Int# -> Word#-indexWord16Array# = let x = x in x--indexWord32Array# :: ByteArray# -> Int# -> Word#-indexWord32Array# = let x = x in x--indexWord64Array# :: ByteArray# -> Int# -> Word#-indexWord64Array# = let x = x in x---- |Read 8-bit character; offset in bytes.--readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readCharArray# = let x = x in x---- |Read 31-bit character; offset in 4-byte words.--readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readWideCharArray# = let x = x in x--readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readIntArray# = let x = x in x--readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWordArray# = let x = x in x--readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)-readAddrArray# = let x = x in x--readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)-readFloatArray# = let x = x in x--readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)-readDoubleArray# = let x = x in x--readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrArray# = let x = x in x--readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt8Array# = let x = x in x--readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt16Array# = let x = x in x--readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt32Array# = let x = x in x--readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt64Array# = let x = x in x--readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord8Array# = let x = x in x--readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord16Array# = let x = x in x--readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord32Array# = let x = x in x--readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord64Array# = let x = x in x---- |Write 8-bit character; offset in bytes.--writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeCharArray# = let x = x in x---- |Write 31-bit character; offset in 4-byte words.--writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeWideCharArray# = let x = x in x--writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeIntArray# = let x = x in x--writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWordArray# = let x = x in x--writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s-writeAddrArray# = let x = x in x--writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s-writeFloatArray# = let x = x in x--writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s-writeDoubleArray# = let x = x in x--writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrArray# = let x = x in x--writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt8Array# = let x = x in x--writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt16Array# = let x = x in x--writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt32Array# = let x = x in x--writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt64Array# = let x = x in x--writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord8Array# = let x = x in x--writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord16Array# = let x = x in x--writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord32Array# = let x = x in x--writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord64Array# = let x = x in x---- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.---    The two arrays must not be the same array in different states, but this is not checked either.--copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyByteArray# = let x = x in x---- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableByteArray# = let x = x in x---- |Copy a range of the ByteArray# to the memory range starting at the Addr#.---    The ByteArray# and the memory region at Addr# must fully contain the---    specified ranges, but this is not checked. The Addr# must not point into the---    ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked---    either.--copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s-copyByteArrayToAddr# = let x = x in x---- |Copy a range of the MutableByteArray# to the memory range starting at the---    Addr#. The MutableByteArray# and the memory region at Addr# must fully---    contain the specified ranges, but this is not checked. The Addr# must not---    point into the MutableByteArray# (e.g. if the MutableByteArray# were---    pinned), but this is not checked either.--copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s-copyMutableByteArrayToAddr# = let x = x in x---- |Copy a memory range starting at the Addr# to the specified range in the---    MutableByteArray#. The memory region at Addr# and the ByteArray# must fully---    contain the specified ranges, but this is not checked. The Addr# must not---    point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned),---    but this is not checked either.--copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyAddrToByteArray# = let x = x in x---- |Set the range of the MutableByteArray# to the specified character.--setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s-setByteArray# = let x = x in x---- |Machine-level atomic compare and swap on a word within a ByteArray.--casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)-casIntArray# = let x = x in x---- |Machine-level word-sized fetch-and-add within a ByteArray.--fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchAddIntArray# = let x = x in x--data ArrayArray#--data MutableArrayArray# s---- |Create a new mutable array of arrays with the specified number of elements,---     in the specified state thread, with each element recursively referring to the---     newly created array.--newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)-newArrayArray# = let x = x in x--sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#-sameMutableArrayArray# = let x = x in x---- |Make a mutable array of arrays immutable, without copying.--unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)-unsafeFreezeArrayArray# = let x = x in x---- |Return the number of elements in the array.--sizeofArrayArray# :: ArrayArray# -> Int#-sizeofArrayArray# = let x = x in x---- |Return the number of elements in the array.--sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#-sizeofMutableArrayArray# = let x = x in x--indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#-indexByteArrayArray# = let x = x in x--indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#-indexArrayArrayArray# = let x = x in x--readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)-readByteArrayArray# = let x = x in x--readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-readMutableByteArrayArray# = let x = x in x--readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)-readArrayArrayArray# = let x = x in x--readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)-readMutableArrayArrayArray# = let x = x in x--writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s-writeByteArrayArray# = let x = x in x--writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s-writeMutableByteArrayArray# = let x = x in x--writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s-writeArrayArrayArray# = let x = x in x--writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s-writeMutableArrayArrayArray# = let x = x in x---- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.---    The two arrays must not be the same array in different states, but this is not checked either.--copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyArrayArray# = let x = x in x---- |Copy a range of the first MutableArrayArray# to the specified region in the second---    MutableArrayArray#.---    Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableArrayArray# = let x = x in x---- | An arbitrary machine address assumed to point outside--- 	 the garbage-collected heap. --data Addr#---- | The null address. --nullAddr# :: Addr#-nullAddr# = let x = x in x--plusAddr# :: Addr# -> Int# -> Addr#-plusAddr# = let x = x in x---- |Result is meaningless if two @Addr\#@s are so far apart that their--- 	 difference doesn\'t fit in an @Int\#@.--minusAddr# :: Addr# -> Addr# -> Int#-minusAddr# = let x = x in x---- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,--- 	  is divided by the @Int\#@ arg.--remAddr# :: Addr# -> Int# -> Int#-remAddr# = let x = x in x---- |Coerce directly from address to int. Strongly deprecated.--addr2Int# :: Addr# -> Int#-addr2Int# = let x = x in x---- |Coerce directly from int to address. Strongly deprecated.--int2Addr# :: Int# -> Addr#-int2Addr# = let x = x in x--gtAddr# :: Addr# -> Addr# -> Int#-gtAddr# = let x = x in x--geAddr# :: Addr# -> Addr# -> Int#-geAddr# = let x = x in x--eqAddr# :: Addr# -> Addr# -> Int#-eqAddr# = let x = x in x--neAddr# :: Addr# -> Addr# -> Int#-neAddr# = let x = x in x--ltAddr# :: Addr# -> Addr# -> Int#-ltAddr# = let x = x in x--leAddr# :: Addr# -> Addr# -> Int#-leAddr# = let x = x in x---- |Reads 8-bit character; offset in bytes.--indexCharOffAddr# :: Addr# -> Int# -> Char#-indexCharOffAddr# = let x = x in x---- |Reads 31-bit character; offset in 4-byte words.--indexWideCharOffAddr# :: Addr# -> Int# -> Char#-indexWideCharOffAddr# = let x = x in x--indexIntOffAddr# :: Addr# -> Int# -> Int#-indexIntOffAddr# = let x = x in x--indexWordOffAddr# :: Addr# -> Int# -> Word#-indexWordOffAddr# = let x = x in x--indexAddrOffAddr# :: Addr# -> Int# -> Addr#-indexAddrOffAddr# = let x = x in x--indexFloatOffAddr# :: Addr# -> Int# -> Float#-indexFloatOffAddr# = let x = x in x--indexDoubleOffAddr# :: Addr# -> Int# -> Double#-indexDoubleOffAddr# = let x = x in x--indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a-indexStablePtrOffAddr# = let x = x in x--indexInt8OffAddr# :: Addr# -> Int# -> Int#-indexInt8OffAddr# = let x = x in x--indexInt16OffAddr# :: Addr# -> Int# -> Int#-indexInt16OffAddr# = let x = x in x--indexInt32OffAddr# :: Addr# -> Int# -> Int#-indexInt32OffAddr# = let x = x in x--indexInt64OffAddr# :: Addr# -> Int# -> Int#-indexInt64OffAddr# = let x = x in x--indexWord8OffAddr# :: Addr# -> Int# -> Word#-indexWord8OffAddr# = let x = x in x--indexWord16OffAddr# :: Addr# -> Int# -> Word#-indexWord16OffAddr# = let x = x in x--indexWord32OffAddr# :: Addr# -> Int# -> Word#-indexWord32OffAddr# = let x = x in x--indexWord64OffAddr# :: Addr# -> Int# -> Word#-indexWord64OffAddr# = let x = x in x---- |Reads 8-bit character; offset in bytes.--readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readCharOffAddr# = let x = x in x---- |Reads 31-bit character; offset in 4-byte words.--readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readWideCharOffAddr# = let x = x in x--readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readIntOffAddr# = let x = x in x--readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWordOffAddr# = let x = x in x--readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)-readAddrOffAddr# = let x = x in x--readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)-readFloatOffAddr# = let x = x in x--readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)-readDoubleOffAddr# = let x = x in x--readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrOffAddr# = let x = x in x--readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt8OffAddr# = let x = x in x--readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt16OffAddr# = let x = x in x--readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt32OffAddr# = let x = x in x--readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt64OffAddr# = let x = x in x--readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord8OffAddr# = let x = x in x--readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord16OffAddr# = let x = x in x--readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord32OffAddr# = let x = x in x--readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord64OffAddr# = let x = x in x--writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeCharOffAddr# = let x = x in x--writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeWideCharOffAddr# = let x = x in x--writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeIntOffAddr# = let x = x in x--writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWordOffAddr# = let x = x in x--writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s-writeAddrOffAddr# = let x = x in x--writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s-writeFloatOffAddr# = let x = x in x--writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s-writeDoubleOffAddr# = let x = x in x--writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrOffAddr# = let x = x in x--writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt8OffAddr# = let x = x in x--writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt16OffAddr# = let x = x in x--writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt32OffAddr# = let x = x in x--writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt64OffAddr# = let x = x in x--writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord8OffAddr# = let x = x in x--writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord16OffAddr# = let x = x in x--writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord32OffAddr# = let x = x in x--writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord64OffAddr# = let x = x in x---- |A @MutVar\#@ behaves like a single-element mutable array.--data MutVar# s a---- |Create @MutVar\#@ with specified initial value in specified state thread.--newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)-newMutVar# = let x = x in x---- |Read contents of @MutVar\#@. Result is not yet evaluated.--readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)-readMutVar# = let x = x in x---- |Write contents of @MutVar\#@.--writeMutVar# :: MutVar# s a -> a -> State# s -> State# s-writeMutVar# = let x = x in x--sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#-sameMutVar# = let x = x in x--atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)-atomicModifyMutVar# = let x = x in x--casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)-casMutVar# = let x = x in x--catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catch# = let x = x in x--raise# :: a -> b-raise# = let x = x in x--raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)-raiseIO# = let x = x in x--maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskAsyncExceptions# = let x = x in x--maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskUninterruptible# = let x = x in x--unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-unmaskAsyncExceptions# = let x = x in x--getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-getMaskingState# = let x = x in x--data TVar# s a--atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-atomically# = let x = x in x--retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)-retry# = let x = x in x--catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchRetry# = let x = x in x--catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchSTM# = let x = x in x--check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)-check# = let x = x in x---- |Create a new @TVar\#@ holding a specified initial value.--newTVar# :: a -> State# s -> (# State# s,TVar# s a #)-newTVar# = let x = x in x---- |Read contents of @TVar\#@.  Result is not yet evaluated.--readTVar# :: TVar# s a -> State# s -> (# State# s,a #)-readTVar# = let x = x in x---- |Read contents of @TVar\#@ outside an STM transaction--readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)-readTVarIO# = let x = x in x---- |Write contents of @TVar\#@.--writeTVar# :: TVar# s a -> a -> State# s -> State# s-writeTVar# = let x = x in x--sameTVar# :: TVar# s a -> TVar# s a -> Int#-sameTVar# = let x = x in x---- | A shared mutable variable (/not/ the same as a @MutVar\#@!).--- 	(Note: in a non-concurrent implementation, @(MVar\# a)@ can be--- 	represented by @(MutVar\# (Maybe a))@.) --data MVar# s a---- |Create new @MVar\#@; initially empty.--newMVar# :: State# s -> (# State# s,MVar# s a #)-newMVar# = let x = x in x---- |If @MVar\#@ is empty, block until it becomes full.---    Then remove and return its contents, and set it empty.--takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)-takeMVar# = let x = x in x---- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.---    Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty.--tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryTakeMVar# = let x = x in x---- |If @MVar\#@ is full, block until it becomes empty.---    Then store value arg as its new contents.--putMVar# :: MVar# s a -> a -> State# s -> State# s-putMVar# = let x = x in x---- |If @MVar\#@ is full, immediately return with integer 0.---     Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1.--tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)-tryPutMVar# = let x = x in x---- |If @MVar\#@ is empty, block until it becomes full.---    Then read its contents without modifying the MVar, without possibility---    of intervention from other threads.--readMVar# :: MVar# s a -> State# s -> (# State# s,a #)-readMVar# = let x = x in x---- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.---    Otherwise, return with integer 1 and contents of @MVar\#@.--tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryReadMVar# = let x = x in x--sameMVar# :: MVar# s a -> MVar# s a -> Int#-sameMVar# = let x = x in x---- |Return 1 if @MVar\#@ is empty; 0 otherwise.--isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)-isEmptyMVar# = let x = x in x---- |Sleep specified number of microseconds.--delay# :: Int# -> State# s -> State# s-delay# = let x = x in x---- |Block until input is available on specified file descriptor.--waitRead# :: Int# -> State# s -> State# s-waitRead# = let x = x in x---- |Block until output is possible on specified file descriptor.--waitWrite# :: Int# -> State# s -> State# s-waitWrite# = let x = x in x---- | @State\#@ is the primitive, unlifted type of states.  It has--- 	one type parameter, thus @State\# RealWorld@, or @State\# s@,--- 	where s is a type variable. The only purpose of the type parameter--- 	is to keep different state threads separate.  It is represented by--- 	nothing at all. --data State# s---- | @RealWorld@ is deeply magical.  It is /primitive/, but it is not--- 	/unlifted/ (hence @ptrArg@).  We never manipulate values of type--- 	@RealWorld@; it\'s only used in the type system, to parameterise @State\#@. --data RealWorld---- |(In a non-concurrent implementation, this can be a singleton--- 	type, whose (unique) value is returned by @myThreadId\#@.  The--- 	other operations can be omitted.)--data ThreadId#--fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-fork# = let x = x in x--forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-forkOn# = let x = x in x--killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)-killThread# = let x = x in x--yield# :: State# (RealWorld) -> State# (RealWorld)-yield# = let x = x in x--myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-myThreadId# = let x = x in x--labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)-labelThread# = let x = x in x--isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-isCurrentThreadBound# = let x = x in x--noDuplicate# :: State# (RealWorld) -> State# (RealWorld)-noDuplicate# = let x = x in x--threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)-threadStatus# = let x = x in x--data Weak# b--mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeak# = let x = x in x--mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeakNoFinalizer# = let x = x in x---- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C---      function pointer @fptr@ to a weak pointer @w@ as a finalizer. If---      @flag@ is zero, @fptr@ will be called with one argument,---      @ptr@. Otherwise, it will be called with two arguments,---      @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns---      1 on success, or 0 if @w@ is already dead. --addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)-addCFinalizerToWeak# = let x = x in x--deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)-deRefWeak# = let x = x in x--finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)-finalizeWeak# = let x = x in x--touch# :: o -> State# (RealWorld) -> State# (RealWorld)-touch# = let x = x in x--data StablePtr# a--data StableName# a--makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)-makeStablePtr# = let x = x in x--deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)-deRefStablePtr# = let x = x in x--eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#-eqStablePtr# = let x = x in x--makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)-makeStableName# = let x = x in x--eqStableName# :: StableName# a -> StableName# b -> Int#-eqStableName# = let x = x in x--stableNameToInt# :: StableName# a -> Int#-stableNameToInt# = let x = x in x--reallyUnsafePtrEquality# :: a -> a -> Int#-reallyUnsafePtrEquality# = let x = x in x--par# :: a -> Int#-par# = let x = x in x--spark# :: a -> State# s -> (# State# s,a #)-spark# = let x = x in x--seq# :: a -> State# s -> (# State# s,a #)-seq# = let x = x in x--getSpark# :: State# s -> (# State# s,Int#,a #)-getSpark# = let x = x in x---- | Returns the number of sparks in the local spark pool. --numSparks# :: State# s -> (# State# s,Int# #)-numSparks# = let x = x in x--parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parGlobal# = let x = x in x--parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parLocal# = let x = x in x--parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#-parAt# = let x = x in x--parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parAtAbs# = let x = x in x--parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parAtRel# = let x = x in x--parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#-parAtForNow# = let x = x in x--dataToTag# :: a -> Int#-dataToTag# = let x = x in x--tagToEnum# :: Int# -> a-tagToEnum# = let x = x in x---- |Primitive bytecode type.--data BCO#---- |Convert an @Addr\#@ to a followable Any type.--addrToAny# :: Addr# -> (# a #)-addrToAny# = let x = x in x--mkApUpd0# :: BCO# -> (# a #)-mkApUpd0# = let x = x in x--newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)-newBCO# = let x = x in x--unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)-unpackClosure# = let x = x in x--getApStackVal# :: a -> Int# -> (# Int#,b #)-getApStackVal# = let x = x in x--getCCSOf# :: a -> State# s -> (# State# s,Addr# #)-getCCSOf# = let x = x in x---- | Returns the current @CostCentreStack@ (value is @NULL@ if---      not profiling).  Takes a dummy argument which can be used to---      avoid the call to @getCCCS\#@ being floated out by the---      simplifier, which would result in an uninformative stack---      (\"CAF\"). --getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)-getCurrentCCS# = let x = x in x---- | The type constructor @Proxy#@ is used to bear witness to some---    type variable. It\'s used when you want to pass around proxy values---    for doing things like modelling type applications. A @Proxy#@---    is not only unboxed, it also has a polymorphic kind, and has no---    runtime representation, being totally free. --data Proxy# a---- | Witness for an unboxed @Proxy#@ value, which has no runtime---    representation. --proxy# :: Proxy# a-proxy# = let x = x in x---- | Evaluates its first argument to head normal form, and then returns its second--- 	argument as the result. --seq :: a -> b -> b-seq = let x = x in x---- | The type constructor @Any@ is type to which you can unsafely coerce any--- 	lifted type, and back.--- --- 	  * It is lifted, and hence represented by a pointer--- --- 	  * It does not claim to be a /data/ type, and that\'s important for--- 	    the code generator, because the code gen may /enter/ a data value--- 	    but never enters a function value.--- --- 	It\'s also used to instantiate un-constrained type variables after type--- 	checking.  For example, @length@ has type--- --- 	@length :: forall a. [a] -> Int@--- --- 	and the list datacon for the empty list has type--- --- 	@[] :: forall a. [a]@--- --- 	In order to compose these two terms as @length []@ a type--- 	application is required, but there is no constraint on the--- 	choice.  In this situation GHC uses @Any@:--- --- 	@length (Any *) ([] (Any *))@--- ---         Note that @Any@ is kind polymorphic, and takes a kind @k@ as its---         first argument. The kind of @Any@ is thus @forall k. k -> k@.--data Any k---- | The kind @AnyK@ is the kind level counterpart to @Any@. In a---         kind polymorphic setting, a similar example to the length of the empty---         list can be given at the type level:--- ---         @type family Length (l :: [k]) :: Nat@---         @type instance Length [] = Zero@--- ---         When @Length@ is applied to the empty (promoted) list it will have---         the kind @Length AnyK []@.--- ---         @AnyK@ is currently not exported and cannot be used directly, but---         you might see it in debug output from the compiler.---         --data AnyK---- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That--- 	is, it allows you to coerce any type into any other type. If you use this function,--- 	you had better get it right, otherwise segmentation faults await. It is generally--- 	used when you want to write a program that you know is well-typed, but where Haskell\'s--- 	type system is not expressive enough to prove that it is well typed.--- ---         The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to---         spurious compile-time or run-time crashes):--- ---          * Casting any lifted type to @Any@--- ---          * Casting @Any@ back to the real type--- ---          * Casting an unboxed type to another unboxed type of the same size---            (but not coercions between floating-point and integral types)--- ---          * Casting between two types that have the same runtime representation.  One case is when---            the two types differ only in \"phantom\" type parameters, for example---            @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is---            known to be empty.  Also, a @newtype@ of a type @T@ has the same representation---            at runtime as @T@.--- ---         Other uses of @unsafeCoerce\#@ are undefined.  In particular, you should not use--- 	@unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also--- 	an algebraic data type.  For example, do not cast @Int->Int@ to @Bool@, even if---         you later cast that @Bool@ back to @Int->Int@ before applying it.  The reasons---         have to do with GHC\'s internal representation details (for the congnoscenti, data values--- 	can be entered but function closures cannot).  If you want a safe type to cast things--- 	to, use @Any@, which is not an algebraic data type.--- ---         --unsafeCoerce# :: a -> b-unsafeCoerce# = let x = x in x---- | Emits an event via the RTS tracing framework.  The contents---      of the event is the zero-terminated byte string passed as the first---      argument.  The event will be emitted either to the .eventlog file,---      or to stderr, depending on the runtime RTS flags. --traceEvent# :: Addr# -> State# s -> State# s-traceEvent# = let x = x in x---- | Emits a marker event via the RTS tracing framework.  The contents---      of the event is the zero-terminated byte string passed as the first---      argument.  The event will be emitted either to the .eventlog file,---      or to stderr, depending on the runtime RTS flags. --traceMarker# :: Addr# -> State# s -> State# s-traceMarker# = let x = x in x---- | The function @coerce@ allows you to safely convert between values of---      types that have the same representation with no run-time overhead. In the---      simplest case you can use it instead of a newtype constructor, to go from---      the newtype\'s concrete type to the abstract type. But it also works in---      more complicated settings, e.g. converting a list of newtypes to a list of---      concrete types.---    --coerce :: Coercible a b => a -> b-coerce = let x = x in x---- | This two-parameter class has instances for types @a@ and @b@ if---      the compiler can infer that they have the same representation. This class---      does not have regular instances; instead they are created on-the-fly during---      type-checking. Trying to manually declare an instance of @Coercible@---      is an error.--- ---      Nevertheless one can pretend that the following three kinds of instances---      exist. First, as a trivial base-case:--- ---      @instance a a@--- ---      Furthermore, for every type constructor there is---      an instance that allows to coerce under the type constructor. For---      example, let @D@ be a prototypical type constructor (@data@ or @newtype@) with three type arguments, which have roles Nominal,---      Representational resp. Phantom. Then there is an instance of the form--- ---      @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@--- ---      Note that the nominal type arguments are equal, the representational type---      arguments can differ, but need to have a @Coercible@ instance---      themself, and the phantom type arguments can be changed arbitrarily.--- ---      In SafeHaskell code, this instance is only usable if the constructors of---      every type constructor used in the definition of @D@ (including---      those of @D@ itself) are in scope.--- ---      The third kind of instance exists for every @newtype NT = MkNT T@ and---      comes in two variants, namely--- ---      @instance Coercible a T => Coercible a NT@--- ---      @instance Coercible T b => Coercible NT b@--- ---      This instance is only usable if the constructor @MkNT@ is in scope.--- ---      If, as a library author of a type constructor like @Set a@, you---      want to prevent a user of your module to write---      @coerce :: Set T -> Set NT@,---      you need to set the role of @Set@\'s type parameter to Nominal.---    --class Coercible a b--data Int8X16#--data Int16X8#--data Int32X4#--data Int64X2#--data Int8X32#--data Int16X16#--data Int32X8#--data Int64X4#--data Int8X64#--data Int16X32#--data Int32X16#--data Int64X8#--data Word8X16#--data Word16X8#--data Word32X4#--data Word64X2#--data Word8X32#--data Word16X16#--data Word32X8#--data Word64X4#--data Word8X64#--data Word16X32#--data Word32X16#--data Word64X8#--data FloatX4#--data DoubleX2#--data FloatX8#--data DoubleX4#--data FloatX16#--data DoubleX8#---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X16# :: Int# -> Int8X16#-broadcastInt8X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X8# :: Int# -> Int16X8#-broadcastInt16X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X4# :: Int# -> Int32X4#-broadcastInt32X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X2# :: Int# -> Int64X2#-broadcastInt64X2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X32# :: Int# -> Int8X32#-broadcastInt8X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X16# :: Int# -> Int16X16#-broadcastInt16X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X8# :: Int# -> Int32X8#-broadcastInt32X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X4# :: Int# -> Int64X4#-broadcastInt64X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X64# :: Int# -> Int8X64#-broadcastInt8X64# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X32# :: Int# -> Int16X32#-broadcastInt16X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X16# :: Int# -> Int32X16#-broadcastInt32X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X8# :: Int# -> Int64X8#-broadcastInt64X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X16# :: Word# -> Word8X16#-broadcastWord8X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X8# :: Word# -> Word16X8#-broadcastWord16X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X4# :: Word# -> Word32X4#-broadcastWord32X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X2# :: Word# -> Word64X2#-broadcastWord64X2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X32# :: Word# -> Word8X32#-broadcastWord8X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X16# :: Word# -> Word16X16#-broadcastWord16X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X8# :: Word# -> Word32X8#-broadcastWord32X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X4# :: Word# -> Word64X4#-broadcastWord64X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X64# :: Word# -> Word8X64#-broadcastWord8X64# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X32# :: Word# -> Word16X32#-broadcastWord16X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X16# :: Word# -> Word32X16#-broadcastWord32X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X8# :: Word# -> Word64X8#-broadcastWord64X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX4# :: Float# -> FloatX4#-broadcastFloatX4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX2# :: Double# -> DoubleX2#-broadcastDoubleX2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX8# :: Float# -> FloatX8#-broadcastFloatX8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX4# :: Double# -> DoubleX4#-broadcastDoubleX4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX16# :: Float# -> FloatX16#-broadcastFloatX16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX8# :: Double# -> DoubleX8#-broadcastDoubleX8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16#-packInt8X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8#-packInt16X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4#-packInt32X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X2# :: (# Int#,Int# #) -> Int64X2#-packInt64X2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X32#-packInt8X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X16#-packInt16X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8#-packInt32X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4#-packInt64X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X64# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X64#-packInt8X64# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X32#-packInt16X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X16#-packInt32X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8#-packInt64X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X16#-packWord8X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8#-packWord16X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4#-packWord32X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X2# :: (# Word#,Word# #) -> Word64X2#-packWord64X2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X32#-packWord8X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X16#-packWord16X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8#-packWord32X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4#-packWord64X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X64# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X64#-packWord8X64# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X32#-packWord16X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X16#-packWord32X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8#-packWord64X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4#-packFloatX4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX2# :: (# Double#,Double# #) -> DoubleX2#-packDoubleX2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8#-packFloatX8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4#-packDoubleX4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX16# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX16#-packFloatX16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8#-packDoubleX8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)-unpackInt32X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)-unpackInt64X2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X32# :: Int8X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X16# :: Int16X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt32X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #)-unpackInt64X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X64# :: Int8X64# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X64# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X32# :: Int16X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X16# :: Int32X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt32X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt64X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X16# :: Word8X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #)-unpackWord32X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X2# :: Word64X2# -> (# Word#,Word# #)-unpackWord64X2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X32# :: Word8X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X16# :: Word16X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord32X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #)-unpackWord64X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X64# :: Word8X64# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X64# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X32# :: Word16X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X16# :: Word32X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord32X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord64X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)-unpackFloatX4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)-unpackDoubleX2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)-unpackFloatX8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #)-unpackDoubleX4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX16# :: FloatX16# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)-unpackFloatX16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #)-unpackDoubleX8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#-insertInt8X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#-insertInt16X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#-insertInt32X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#-insertInt64X2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#-insertInt8X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#-insertInt16X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#-insertInt32X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#-insertInt64X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#-insertInt8X64# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#-insertInt16X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#-insertInt32X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#-insertInt64X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#-insertWord8X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#-insertWord16X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#-insertWord32X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#-insertWord64X2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#-insertWord8X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#-insertWord16X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#-insertWord32X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#-insertWord64X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#-insertWord8X64# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#-insertWord16X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#-insertWord32X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#-insertWord64X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#-insertFloatX4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#-insertDoubleX2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#-insertFloatX8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#-insertDoubleX4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#-insertFloatX16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#-insertDoubleX8# = let x = x in x---- | Add two vectors element-wise. --plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-plusInt8X16# = let x = x in x---- | Add two vectors element-wise. --plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-plusInt16X8# = let x = x in x---- | Add two vectors element-wise. --plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-plusInt32X4# = let x = x in x---- | Add two vectors element-wise. --plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-plusInt64X2# = let x = x in x---- | Add two vectors element-wise. --plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-plusInt8X32# = let x = x in x---- | Add two vectors element-wise. --plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-plusInt16X16# = let x = x in x---- | Add two vectors element-wise. --plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-plusInt32X8# = let x = x in x---- | Add two vectors element-wise. --plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-plusInt64X4# = let x = x in x---- | Add two vectors element-wise. --plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-plusInt8X64# = let x = x in x---- | Add two vectors element-wise. --plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-plusInt16X32# = let x = x in x---- | Add two vectors element-wise. --plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-plusInt32X16# = let x = x in x---- | Add two vectors element-wise. --plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-plusInt64X8# = let x = x in x---- | Add two vectors element-wise. --plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-plusWord8X16# = let x = x in x---- | Add two vectors element-wise. --plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-plusWord16X8# = let x = x in x---- | Add two vectors element-wise. --plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-plusWord32X4# = let x = x in x---- | Add two vectors element-wise. --plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-plusWord64X2# = let x = x in x---- | Add two vectors element-wise. --plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-plusWord8X32# = let x = x in x---- | Add two vectors element-wise. --plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-plusWord16X16# = let x = x in x---- | Add two vectors element-wise. --plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-plusWord32X8# = let x = x in x---- | Add two vectors element-wise. --plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-plusWord64X4# = let x = x in x---- | Add two vectors element-wise. --plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-plusWord8X64# = let x = x in x---- | Add two vectors element-wise. --plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-plusWord16X32# = let x = x in x---- | Add two vectors element-wise. --plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-plusWord32X16# = let x = x in x---- | Add two vectors element-wise. --plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-plusWord64X8# = let x = x in x---- | Add two vectors element-wise. --plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-plusFloatX4# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-plusDoubleX2# = let x = x in x---- | Add two vectors element-wise. --plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-plusFloatX8# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-plusDoubleX4# = let x = x in x---- | Add two vectors element-wise. --plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-plusFloatX16# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-plusDoubleX8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-minusInt8X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-minusInt16X8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-minusInt32X4# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-minusInt64X2# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-minusInt8X32# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-minusInt16X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-minusInt32X8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-minusInt64X4# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-minusInt8X64# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-minusInt16X32# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-minusInt32X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-minusInt64X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-minusWord8X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-minusWord16X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-minusWord32X4# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-minusWord64X2# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-minusWord8X32# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-minusWord16X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-minusWord32X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-minusWord64X4# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-minusWord8X64# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-minusWord16X32# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-minusWord32X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-minusWord64X8# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-minusFloatX4# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-minusDoubleX2# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-minusFloatX8# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-minusDoubleX4# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-minusFloatX16# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-minusDoubleX8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-timesInt8X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-timesInt16X8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-timesInt32X4# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-timesInt64X2# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-timesInt8X32# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-timesInt16X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-timesInt32X8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-timesInt64X4# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-timesInt8X64# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-timesInt16X32# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-timesInt32X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-timesInt64X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-timesWord8X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-timesWord16X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-timesWord32X4# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-timesWord64X2# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-timesWord8X32# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-timesWord16X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-timesWord32X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-timesWord64X4# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-timesWord8X64# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-timesWord16X32# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-timesWord32X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-timesWord64X8# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-timesFloatX4# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-timesDoubleX2# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-timesFloatX8# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-timesDoubleX4# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-timesFloatX16# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-timesDoubleX8# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-divideFloatX4# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-divideDoubleX2# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-divideFloatX8# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-divideDoubleX4# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-divideFloatX16# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-divideDoubleX8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-quotInt8X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-quotInt16X8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-quotInt32X4# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-quotInt64X2# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-quotInt8X32# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-quotInt16X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-quotInt32X8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-quotInt64X4# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-quotInt8X64# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-quotInt16X32# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-quotInt32X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-quotInt64X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-quotWord8X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-quotWord16X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-quotWord32X4# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-quotWord64X2# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-quotWord8X32# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-quotWord16X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-quotWord32X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-quotWord64X4# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-quotWord8X64# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-quotWord16X32# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-quotWord32X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-quotWord64X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-remInt8X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-remInt16X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-remInt32X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-remInt64X2# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-remInt8X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-remInt16X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-remInt32X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-remInt64X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-remInt8X64# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-remInt16X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-remInt32X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-remInt64X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-remWord8X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-remWord16X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-remWord32X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-remWord64X2# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-remWord8X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-remWord16X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-remWord32X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-remWord64X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-remWord8X64# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-remWord16X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-remWord32X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-remWord64X8# = let x = x in x---- | Negate element-wise. --negateInt8X16# :: Int8X16# -> Int8X16#-negateInt8X16# = let x = x in x---- | Negate element-wise. --negateInt16X8# :: Int16X8# -> Int16X8#-negateInt16X8# = let x = x in x---- | Negate element-wise. --negateInt32X4# :: Int32X4# -> Int32X4#-negateInt32X4# = let x = x in x---- | Negate element-wise. --negateInt64X2# :: Int64X2# -> Int64X2#-negateInt64X2# = let x = x in x---- | Negate element-wise. --negateInt8X32# :: Int8X32# -> Int8X32#-negateInt8X32# = let x = x in x---- | Negate element-wise. --negateInt16X16# :: Int16X16# -> Int16X16#-negateInt16X16# = let x = x in x---- | Negate element-wise. --negateInt32X8# :: Int32X8# -> Int32X8#-negateInt32X8# = let x = x in x---- | Negate element-wise. --negateInt64X4# :: Int64X4# -> Int64X4#-negateInt64X4# = let x = x in x---- | Negate element-wise. --negateInt8X64# :: Int8X64# -> Int8X64#-negateInt8X64# = let x = x in x---- | Negate element-wise. --negateInt16X32# :: Int16X32# -> Int16X32#-negateInt16X32# = let x = x in x---- | Negate element-wise. --negateInt32X16# :: Int32X16# -> Int32X16#-negateInt32X16# = let x = x in x---- | Negate element-wise. --negateInt64X8# :: Int64X8# -> Int64X8#-negateInt64X8# = let x = x in x---- | Negate element-wise. --negateFloatX4# :: FloatX4# -> FloatX4#-negateFloatX4# = let x = x in x---- | Negate element-wise. --negateDoubleX2# :: DoubleX2# -> DoubleX2#-negateDoubleX2# = let x = x in x---- | Negate element-wise. --negateFloatX8# :: FloatX8# -> FloatX8#-negateFloatX8# = let x = x in x---- | Negate element-wise. --negateDoubleX4# :: DoubleX4# -> DoubleX4#-negateDoubleX4# = let x = x in x---- | Negate element-wise. --negateFloatX16# :: FloatX16# -> FloatX16#-negateFloatX16# = let x = x in x---- | Negate element-wise. --negateDoubleX8# :: DoubleX8# -> DoubleX8#-negateDoubleX8# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#-indexInt8X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#-indexInt16X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#-indexInt32X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#-indexInt64X2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#-indexInt8X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#-indexInt16X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#-indexInt32X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#-indexInt64X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#-indexInt8X64Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#-indexInt16X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#-indexInt32X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#-indexInt64X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#-indexWord8X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#-indexWord16X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#-indexWord32X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#-indexWord64X2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#-indexWord8X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#-indexWord16X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#-indexWord32X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#-indexWord64X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#-indexWord8X64Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#-indexWord16X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#-indexWord32X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#-indexWord64X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#-indexFloatX4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#-indexDoubleX2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#-indexFloatX8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#-indexDoubleX4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#-indexFloatX16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#-indexDoubleX8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64X2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8X64Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64X2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8X64Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatX4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleX2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatX8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleX4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatX16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleX8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s-writeInt8X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s-writeInt16X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s-writeInt32X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s-writeInt64X2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s-writeInt8X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s-writeInt16X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s-writeInt32X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s-writeInt64X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s-writeInt8X64Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s-writeInt16X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s-writeInt32X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s-writeInt64X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s-writeWord8X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s-writeWord16X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s-writeWord32X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s-writeWord64X2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s-writeWord8X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s-writeWord16X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s-writeWord32X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s-writeWord64X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s-writeWord8X64Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s-writeWord16X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s-writeWord32X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s-writeWord64X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s-writeFloatX4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleX2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s-writeFloatX8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleX4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s-writeFloatX16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleX8Array# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#-indexInt8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#-indexInt16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#-indexInt32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#-indexInt64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#-indexInt8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#-indexInt16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#-indexInt32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#-indexInt64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#-indexInt8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#-indexInt16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#-indexInt32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#-indexInt64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#-indexWord8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#-indexWord16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#-indexWord32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#-indexWord64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#-indexWord8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#-indexWord16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#-indexWord32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#-indexWord64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#-indexWord8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#-indexWord16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#-indexWord32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#-indexWord64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#-indexFloatX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#-indexDoubleX2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#-indexFloatX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#-indexDoubleX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#-indexFloatX16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#-indexDoubleX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleX2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatX16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleX8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s-writeInt8X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s-writeInt16X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s-writeInt32X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s-writeInt64X2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s-writeInt8X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s-writeInt16X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s-writeInt32X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s-writeInt64X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s-writeInt8X64OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s-writeInt16X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s-writeInt32X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s-writeInt64X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s-writeWord8X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s-writeWord16X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s-writeWord32X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s-writeWord64X2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s-writeWord8X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s-writeWord16X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s-writeWord32X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s-writeWord64X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s-writeWord8X64OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s-writeWord16X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s-writeWord32X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s-writeWord64X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s-writeFloatX4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleX2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s-writeFloatX8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleX4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s-writeFloatX16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleX8OffAddr# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#-indexInt8ArrayAsInt8X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#-indexInt16ArrayAsInt16X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#-indexInt32ArrayAsInt32X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#-indexInt64ArrayAsInt64X2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#-indexInt8ArrayAsInt8X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#-indexInt16ArrayAsInt16X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#-indexInt32ArrayAsInt32X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#-indexInt64ArrayAsInt64X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#-indexInt8ArrayAsInt8X64# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#-indexInt16ArrayAsInt16X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#-indexInt32ArrayAsInt32X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#-indexInt64ArrayAsInt64X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#-indexWord8ArrayAsWord8X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#-indexWord16ArrayAsWord16X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#-indexWord32ArrayAsWord32X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#-indexWord64ArrayAsWord64X2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#-indexWord8ArrayAsWord8X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#-indexWord16ArrayAsWord16X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#-indexWord32ArrayAsWord32X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#-indexWord64ArrayAsWord64X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#-indexWord8ArrayAsWord8X64# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#-indexWord16ArrayAsWord16X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#-indexWord32ArrayAsWord32X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#-indexWord64ArrayAsWord64X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#-indexFloatArrayAsFloatX4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#-indexDoubleArrayAsDoubleX2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#-indexFloatArrayAsFloatX8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#-indexDoubleArrayAsDoubleX4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#-indexFloatArrayAsFloatX16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#-indexDoubleArrayAsDoubleX8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8ArrayAsInt8X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16ArrayAsInt16X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32ArrayAsInt32X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64ArrayAsInt64X2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8ArrayAsInt8X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16ArrayAsInt16X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32ArrayAsInt32X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64ArrayAsInt64X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8ArrayAsInt8X64# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16ArrayAsInt16X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32ArrayAsInt32X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64ArrayAsInt64X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8ArrayAsWord8X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16ArrayAsWord16X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32ArrayAsWord32X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64ArrayAsWord64X2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8ArrayAsWord8X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16ArrayAsWord16X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32ArrayAsWord32X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64ArrayAsWord64X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8ArrayAsWord8X64# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16ArrayAsWord16X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32ArrayAsWord32X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64ArrayAsWord64X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatArrayAsFloatX4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleArrayAsDoubleX2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatArrayAsFloatX8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleArrayAsDoubleX4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatArrayAsFloatX16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleArrayAsDoubleX8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s-writeInt8ArrayAsInt8X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s-writeInt16ArrayAsInt16X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s-writeInt32ArrayAsInt32X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s-writeInt64ArrayAsInt64X2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s-writeInt8ArrayAsInt8X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s-writeInt16ArrayAsInt16X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s-writeInt32ArrayAsInt32X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s-writeInt64ArrayAsInt64X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s-writeInt8ArrayAsInt8X64# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s-writeInt16ArrayAsInt16X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s-writeInt32ArrayAsInt32X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s-writeInt64ArrayAsInt64X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s-writeWord8ArrayAsWord8X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s-writeWord16ArrayAsWord16X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s-writeWord32ArrayAsWord32X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s-writeWord64ArrayAsWord64X2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s-writeWord8ArrayAsWord8X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s-writeWord16ArrayAsWord16X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s-writeWord32ArrayAsWord32X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s-writeWord64ArrayAsWord64X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s-writeWord8ArrayAsWord8X64# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s-writeWord16ArrayAsWord16X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s-writeWord32ArrayAsWord32X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s-writeWord64ArrayAsWord64X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s-writeFloatArrayAsFloatX4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleArrayAsDoubleX2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s-writeFloatArrayAsFloatX8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleArrayAsDoubleX4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s-writeFloatArrayAsFloatX16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleArrayAsDoubleX8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#-indexInt8OffAddrAsInt8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#-indexInt16OffAddrAsInt16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#-indexInt32OffAddrAsInt32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#-indexInt64OffAddrAsInt64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#-indexInt8OffAddrAsInt8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#-indexInt16OffAddrAsInt16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#-indexInt32OffAddrAsInt32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#-indexInt64OffAddrAsInt64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#-indexInt8OffAddrAsInt8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#-indexInt16OffAddrAsInt16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#-indexInt32OffAddrAsInt32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#-indexInt64OffAddrAsInt64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#-indexWord8OffAddrAsWord8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#-indexWord16OffAddrAsWord16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#-indexWord32OffAddrAsWord32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#-indexWord64OffAddrAsWord64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#-indexWord8OffAddrAsWord8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#-indexWord16OffAddrAsWord16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#-indexWord32OffAddrAsWord32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#-indexWord64OffAddrAsWord64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#-indexWord8OffAddrAsWord8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#-indexWord16OffAddrAsWord16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#-indexWord32OffAddrAsWord32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#-indexWord64OffAddrAsWord64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#-indexFloatOffAddrAsFloatX4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#-indexDoubleOffAddrAsDoubleX2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#-indexFloatOffAddrAsFloatX8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#-indexDoubleOffAddrAsDoubleX4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#-indexFloatOffAddrAsFloatX16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#-indexDoubleOffAddrAsDoubleX8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8OffAddrAsInt8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16OffAddrAsInt16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32OffAddrAsInt32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64OffAddrAsInt64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8OffAddrAsInt8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16OffAddrAsInt16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32OffAddrAsInt32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64OffAddrAsInt64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8OffAddrAsInt8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16OffAddrAsInt16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32OffAddrAsInt32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64OffAddrAsInt64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8OffAddrAsWord8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16OffAddrAsWord16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32OffAddrAsWord32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64OffAddrAsWord64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8OffAddrAsWord8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16OffAddrAsWord16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32OffAddrAsWord32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64OffAddrAsWord64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8OffAddrAsWord8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16OffAddrAsWord16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32OffAddrAsWord32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64OffAddrAsWord64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatOffAddrAsFloatX4# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleOffAddrAsDoubleX2# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatOffAddrAsFloatX8# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleOffAddrAsDoubleX4# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatOffAddrAsFloatX16# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleOffAddrAsDoubleX8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s-writeInt8OffAddrAsInt8X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s-writeInt16OffAddrAsInt16X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s-writeInt32OffAddrAsInt32X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s-writeInt64OffAddrAsInt64X2# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s-writeInt8OffAddrAsInt8X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s-writeInt16OffAddrAsInt16X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s-writeInt32OffAddrAsInt32X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s-writeInt64OffAddrAsInt64X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s-writeInt8OffAddrAsInt8X64# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s-writeInt16OffAddrAsInt16X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s-writeInt32OffAddrAsInt32X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s-writeInt64OffAddrAsInt64X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s-writeWord8OffAddrAsWord8X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s-writeWord16OffAddrAsWord16X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s-writeWord32OffAddrAsWord32X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s-writeWord64OffAddrAsWord64X2# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s-writeWord8OffAddrAsWord8X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s-writeWord16OffAddrAsWord16X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s-writeWord32OffAddrAsWord32X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s-writeWord64OffAddrAsWord64X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s-writeWord8OffAddrAsWord8X64# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s-writeWord16OffAddrAsWord16X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s-writeWord32OffAddrAsWord32X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s-writeWord64OffAddrAsWord64X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s-writeFloatOffAddrAsFloatX4# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX2# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s-writeFloatOffAddrAsFloatX8# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX4# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s-writeFloatOffAddrAsFloatX16# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX8# = let x = x in x--prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray3# = let x = x in x--prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray3# = let x = x in x--prefetchAddr3# :: Addr# -> Int# -> Addr#-prefetchAddr3# = let x = x in x--prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray2# = let x = x in x--prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray2# = let x = x in x--prefetchAddr2# :: Addr# -> Int# -> Addr#-prefetchAddr2# = let x = x in x--prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray1# = let x = x in x--prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray1# = let x = x in x--prefetchAddr1# :: Addr# -> Int# -> Addr#-prefetchAddr1# = let x = x in x--prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray0# = let x = x in x--prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray0# = let x = x in x--prefetchAddr0# :: Addr# -> Int# -> Addr#-prefetchAddr0# = let x = x in x---
+ GHC/Prim/Exception.hs view
@@ -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# (# #)
+ GHC/Prim/Ext.hs view
@@ -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)++#-}
+ GHC/Prim/Panic.hs view
@@ -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
+ GHC/Prim/PtrEq.hs view
@@ -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#
GHC/PrimopWrappers.hs view
@@ -1,1100 +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#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, BCO#)-{-# NOINLINE gtChar# #-}-gtChar# :: Char# -> Char# -> Int#-gtChar# a1 a2 = (GHC.Prim.gtChar#) a1 a2-{-# NOINLINE geChar# #-}-geChar# :: Char# -> Char# -> Int#-geChar# a1 a2 = (GHC.Prim.geChar#) a1 a2-{-# NOINLINE eqChar# #-}-eqChar# :: Char# -> Char# -> Int#-eqChar# a1 a2 = (GHC.Prim.eqChar#) a1 a2-{-# NOINLINE neChar# #-}-neChar# :: Char# -> Char# -> Int#-neChar# a1 a2 = (GHC.Prim.neChar#) a1 a2-{-# NOINLINE ltChar# #-}-ltChar# :: Char# -> Char# -> Int#-ltChar# a1 a2 = (GHC.Prim.ltChar#) a1 a2-{-# NOINLINE leChar# #-}-leChar# :: Char# -> Char# -> Int#-leChar# a1 a2 = (GHC.Prim.leChar#) a1 a2-{-# NOINLINE ord# #-}-ord# :: Char# -> Int#-ord# a1 = (GHC.Prim.ord#) a1-{-# NOINLINE (+#) #-}-(+#) :: Int# -> Int# -> Int#-(+#) a1 a2 = (GHC.Prim.+#) a1 a2-{-# NOINLINE (-#) #-}-(-#) :: Int# -> Int# -> Int#-(-#) a1 a2 = (GHC.Prim.-#) a1 a2-{-# NOINLINE (*#) #-}-(*#) :: Int# -> Int# -> Int#-(*#) a1 a2 = (GHC.Prim.*#) a1 a2-{-# NOINLINE mulIntMayOflo# #-}-mulIntMayOflo# :: Int# -> Int# -> Int#-mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2-{-# NOINLINE quotInt# #-}-quotInt# :: Int# -> Int# -> Int#-quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2-{-# NOINLINE remInt# #-}-remInt# :: Int# -> Int# -> Int#-remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2-{-# NOINLINE quotRemInt# #-}-quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)-quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2-{-# NOINLINE andI# #-}-andI# :: Int# -> Int# -> Int#-andI# a1 a2 = (GHC.Prim.andI#) a1 a2-{-# NOINLINE orI# #-}-orI# :: Int# -> Int# -> Int#-orI# a1 a2 = (GHC.Prim.orI#) a1 a2-{-# NOINLINE xorI# #-}-xorI# :: Int# -> Int# -> Int#-xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2-{-# NOINLINE notI# #-}-notI# :: Int# -> Int#-notI# a1 = (GHC.Prim.notI#) a1-{-# NOINLINE negateInt# #-}-negateInt# :: Int# -> Int#-negateInt# a1 = (GHC.Prim.negateInt#) a1-{-# NOINLINE addIntC# #-}-addIntC# :: Int# -> Int# -> (# Int#,Int# #)-addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2-{-# NOINLINE subIntC# #-}-subIntC# :: Int# -> Int# -> (# Int#,Int# #)-subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2-{-# NOINLINE (>#) #-}-(>#) :: Int# -> Int# -> Int#-(>#) a1 a2 = (GHC.Prim.>#) a1 a2-{-# NOINLINE (>=#) #-}-(>=#) :: Int# -> Int# -> Int#-(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2-{-# NOINLINE (==#) #-}-(==#) :: Int# -> Int# -> Int#-(==#) a1 a2 = (GHC.Prim.==#) a1 a2-{-# NOINLINE (/=#) #-}-(/=#) :: Int# -> Int# -> Int#-(/=#) a1 a2 = (GHC.Prim./=#) a1 a2-{-# NOINLINE (<#) #-}-(<#) :: Int# -> Int# -> Int#-(<#) a1 a2 = (GHC.Prim.<#) a1 a2-{-# NOINLINE (<=#) #-}-(<=#) :: Int# -> Int# -> Int#-(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2-{-# NOINLINE chr# #-}-chr# :: Int# -> Char#-chr# a1 = (GHC.Prim.chr#) a1-{-# NOINLINE int2Word# #-}-int2Word# :: Int# -> Word#-int2Word# a1 = (GHC.Prim.int2Word#) a1-{-# NOINLINE int2Float# #-}-int2Float# :: Int# -> Float#-int2Float# a1 = (GHC.Prim.int2Float#) a1-{-# NOINLINE int2Double# #-}-int2Double# :: Int# -> Double#-int2Double# a1 = (GHC.Prim.int2Double#) a1-{-# NOINLINE word2Float# #-}-word2Float# :: Word# -> Float#-word2Float# a1 = (GHC.Prim.word2Float#) a1-{-# NOINLINE word2Double# #-}-word2Double# :: Word# -> Double#-word2Double# a1 = (GHC.Prim.word2Double#) a1-{-# NOINLINE uncheckedIShiftL# #-}-uncheckedIShiftL# :: Int# -> Int# -> Int#-uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2-{-# NOINLINE uncheckedIShiftRA# #-}-uncheckedIShiftRA# :: Int# -> Int# -> Int#-uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2-{-# NOINLINE uncheckedIShiftRL# #-}-uncheckedIShiftRL# :: Int# -> Int# -> Int#-uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2-{-# NOINLINE plusWord# #-}-plusWord# :: Word# -> Word# -> Word#-plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2-{-# NOINLINE plusWord2# #-}-plusWord2# :: Word# -> Word# -> (# Word#,Word# #)-plusWord2# a1 a2 = (GHC.Prim.plusWord2#) a1 a2-{-# NOINLINE minusWord# #-}-minusWord# :: Word# -> Word# -> Word#-minusWord# a1 a2 = (GHC.Prim.minusWord#) a1 a2-{-# NOINLINE timesWord# #-}-timesWord# :: Word# -> Word# -> Word#-timesWord# a1 a2 = (GHC.Prim.timesWord#) a1 a2-{-# NOINLINE timesWord2# #-}-timesWord2# :: Word# -> Word# -> (# Word#,Word# #)-timesWord2# a1 a2 = (GHC.Prim.timesWord2#) a1 a2-{-# NOINLINE quotWord# #-}-quotWord# :: Word# -> Word# -> Word#-quotWord# a1 a2 = (GHC.Prim.quotWord#) a1 a2-{-# NOINLINE remWord# #-}-remWord# :: Word# -> Word# -> Word#-remWord# a1 a2 = (GHC.Prim.remWord#) a1 a2-{-# NOINLINE quotRemWord# #-}-quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)-quotRemWord# a1 a2 = (GHC.Prim.quotRemWord#) a1 a2-{-# NOINLINE quotRemWord2# #-}-quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)-quotRemWord2# a1 a2 a3 = (GHC.Prim.quotRemWord2#) a1 a2 a3-{-# NOINLINE and# #-}-and# :: Word# -> Word# -> Word#-and# a1 a2 = (GHC.Prim.and#) a1 a2-{-# NOINLINE or# #-}-or# :: Word# -> Word# -> Word#-or# a1 a2 = (GHC.Prim.or#) a1 a2-{-# NOINLINE xor# #-}-xor# :: Word# -> Word# -> Word#-xor# a1 a2 = (GHC.Prim.xor#) a1 a2-{-# NOINLINE not# #-}-not# :: Word# -> Word#-not# a1 = (GHC.Prim.not#) a1-{-# NOINLINE uncheckedShiftL# #-}-uncheckedShiftL# :: Word# -> Int# -> Word#-uncheckedShiftL# a1 a2 = (GHC.Prim.uncheckedShiftL#) a1 a2-{-# NOINLINE uncheckedShiftRL# #-}-uncheckedShiftRL# :: Word# -> Int# -> Word#-uncheckedShiftRL# a1 a2 = (GHC.Prim.uncheckedShiftRL#) a1 a2-{-# NOINLINE word2Int# #-}-word2Int# :: Word# -> Int#-word2Int# a1 = (GHC.Prim.word2Int#) a1-{-# NOINLINE gtWord# #-}-gtWord# :: Word# -> Word# -> Int#-gtWord# a1 a2 = (GHC.Prim.gtWord#) a1 a2-{-# NOINLINE geWord# #-}-geWord# :: Word# -> Word# -> Int#-geWord# a1 a2 = (GHC.Prim.geWord#) a1 a2-{-# NOINLINE eqWord# #-}-eqWord# :: Word# -> Word# -> Int#-eqWord# a1 a2 = (GHC.Prim.eqWord#) a1 a2-{-# NOINLINE neWord# #-}-neWord# :: Word# -> Word# -> Int#-neWord# a1 a2 = (GHC.Prim.neWord#) a1 a2-{-# NOINLINE ltWord# #-}-ltWord# :: Word# -> Word# -> Int#-ltWord# a1 a2 = (GHC.Prim.ltWord#) a1 a2-{-# NOINLINE leWord# #-}-leWord# :: Word# -> Word# -> Int#-leWord# a1 a2 = (GHC.Prim.leWord#) a1 a2-{-# NOINLINE popCnt8# #-}-popCnt8# :: Word# -> Word#-popCnt8# a1 = (GHC.Prim.popCnt8#) a1-{-# NOINLINE popCnt16# #-}-popCnt16# :: Word# -> Word#-popCnt16# a1 = (GHC.Prim.popCnt16#) a1-{-# NOINLINE popCnt32# #-}-popCnt32# :: Word# -> Word#-popCnt32# a1 = (GHC.Prim.popCnt32#) a1-{-# NOINLINE popCnt64# #-}-popCnt64# :: Word# -> Word#-popCnt64# a1 = (GHC.Prim.popCnt64#) a1-{-# NOINLINE popCnt# #-}-popCnt# :: Word# -> Word#-popCnt# a1 = (GHC.Prim.popCnt#) a1-{-# NOINLINE byteSwap16# #-}-byteSwap16# :: Word# -> Word#-byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1-{-# NOINLINE byteSwap32# #-}-byteSwap32# :: Word# -> Word#-byteSwap32# a1 = (GHC.Prim.byteSwap32#) a1-{-# NOINLINE byteSwap64# #-}-byteSwap64# :: Word# -> Word#-byteSwap64# a1 = (GHC.Prim.byteSwap64#) a1-{-# NOINLINE byteSwap# #-}-byteSwap# :: Word# -> Word#-byteSwap# a1 = (GHC.Prim.byteSwap#) a1-{-# NOINLINE narrow8Int# #-}-narrow8Int# :: Int# -> Int#-narrow8Int# a1 = (GHC.Prim.narrow8Int#) a1-{-# NOINLINE narrow16Int# #-}-narrow16Int# :: Int# -> Int#-narrow16Int# a1 = (GHC.Prim.narrow16Int#) a1-{-# NOINLINE narrow32Int# #-}-narrow32Int# :: Int# -> Int#-narrow32Int# a1 = (GHC.Prim.narrow32Int#) a1-{-# NOINLINE narrow8Word# #-}-narrow8Word# :: Word# -> Word#-narrow8Word# a1 = (GHC.Prim.narrow8Word#) a1-{-# NOINLINE narrow16Word# #-}-narrow16Word# :: Word# -> Word#-narrow16Word# a1 = (GHC.Prim.narrow16Word#) a1-{-# NOINLINE narrow32Word# #-}-narrow32Word# :: Word# -> Word#-narrow32Word# a1 = (GHC.Prim.narrow32Word#) a1-{-# NOINLINE (>##) #-}-(>##) :: Double# -> Double# -> Int#-(>##) a1 a2 = (GHC.Prim.>##) a1 a2-{-# NOINLINE (>=##) #-}-(>=##) :: Double# -> Double# -> Int#-(>=##) a1 a2 = (GHC.Prim.>=##) a1 a2-{-# NOINLINE (==##) #-}-(==##) :: Double# -> Double# -> Int#-(==##) a1 a2 = (GHC.Prim.==##) a1 a2-{-# NOINLINE (/=##) #-}-(/=##) :: Double# -> Double# -> Int#-(/=##) a1 a2 = (GHC.Prim./=##) a1 a2-{-# NOINLINE (<##) #-}-(<##) :: Double# -> Double# -> Int#-(<##) a1 a2 = (GHC.Prim.<##) a1 a2-{-# NOINLINE (<=##) #-}-(<=##) :: Double# -> Double# -> Int#-(<=##) a1 a2 = (GHC.Prim.<=##) a1 a2-{-# NOINLINE (+##) #-}-(+##) :: Double# -> Double# -> Double#-(+##) a1 a2 = (GHC.Prim.+##) a1 a2-{-# NOINLINE (-##) #-}-(-##) :: Double# -> Double# -> Double#-(-##) a1 a2 = (GHC.Prim.-##) a1 a2-{-# NOINLINE (*##) #-}-(*##) :: Double# -> Double# -> Double#-(*##) a1 a2 = (GHC.Prim.*##) a1 a2-{-# NOINLINE (/##) #-}-(/##) :: Double# -> Double# -> Double#-(/##) a1 a2 = (GHC.Prim./##) a1 a2-{-# NOINLINE negateDouble# #-}-negateDouble# :: Double# -> Double#-negateDouble# a1 = (GHC.Prim.negateDouble#) a1-{-# NOINLINE double2Int# #-}-double2Int# :: Double# -> Int#-double2Int# a1 = (GHC.Prim.double2Int#) a1-{-# NOINLINE double2Float# #-}-double2Float# :: Double# -> Float#-double2Float# a1 = (GHC.Prim.double2Float#) a1-{-# NOINLINE expDouble# #-}-expDouble# :: Double# -> Double#-expDouble# a1 = (GHC.Prim.expDouble#) a1-{-# NOINLINE logDouble# #-}-logDouble# :: Double# -> Double#-logDouble# a1 = (GHC.Prim.logDouble#) a1-{-# NOINLINE sqrtDouble# #-}-sqrtDouble# :: Double# -> Double#-sqrtDouble# a1 = (GHC.Prim.sqrtDouble#) a1-{-# NOINLINE sinDouble# #-}-sinDouble# :: Double# -> Double#-sinDouble# a1 = (GHC.Prim.sinDouble#) a1-{-# NOINLINE cosDouble# #-}-cosDouble# :: Double# -> Double#-cosDouble# a1 = (GHC.Prim.cosDouble#) a1-{-# NOINLINE tanDouble# #-}-tanDouble# :: Double# -> Double#-tanDouble# a1 = (GHC.Prim.tanDouble#) a1-{-# NOINLINE asinDouble# #-}-asinDouble# :: Double# -> Double#-asinDouble# a1 = (GHC.Prim.asinDouble#) a1-{-# NOINLINE acosDouble# #-}-acosDouble# :: Double# -> Double#-acosDouble# a1 = (GHC.Prim.acosDouble#) a1-{-# NOINLINE atanDouble# #-}-atanDouble# :: Double# -> Double#-atanDouble# a1 = (GHC.Prim.atanDouble#) a1-{-# NOINLINE sinhDouble# #-}-sinhDouble# :: Double# -> Double#-sinhDouble# a1 = (GHC.Prim.sinhDouble#) a1-{-# NOINLINE coshDouble# #-}-coshDouble# :: Double# -> Double#-coshDouble# a1 = (GHC.Prim.coshDouble#) a1-{-# NOINLINE tanhDouble# #-}-tanhDouble# :: Double# -> Double#-tanhDouble# a1 = (GHC.Prim.tanhDouble#) a1-{-# NOINLINE (**##) #-}-(**##) :: Double# -> Double# -> Double#-(**##) a1 a2 = (GHC.Prim.**##) a1 a2-{-# NOINLINE decodeDouble_2Int# #-}-decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)-decodeDouble_2Int# a1 = (GHC.Prim.decodeDouble_2Int#) a1-{-# NOINLINE gtFloat# #-}-gtFloat# :: Float# -> Float# -> Int#-gtFloat# a1 a2 = (GHC.Prim.gtFloat#) a1 a2-{-# NOINLINE geFloat# #-}-geFloat# :: Float# -> Float# -> Int#-geFloat# a1 a2 = (GHC.Prim.geFloat#) a1 a2-{-# NOINLINE eqFloat# #-}-eqFloat# :: Float# -> Float# -> Int#-eqFloat# a1 a2 = (GHC.Prim.eqFloat#) a1 a2-{-# NOINLINE neFloat# #-}-neFloat# :: Float# -> Float# -> Int#-neFloat# a1 a2 = (GHC.Prim.neFloat#) a1 a2-{-# NOINLINE ltFloat# #-}-ltFloat# :: Float# -> Float# -> Int#-ltFloat# a1 a2 = (GHC.Prim.ltFloat#) a1 a2-{-# NOINLINE leFloat# #-}-leFloat# :: Float# -> Float# -> Int#-leFloat# a1 a2 = (GHC.Prim.leFloat#) a1 a2-{-# NOINLINE plusFloat# #-}-plusFloat# :: Float# -> Float# -> Float#-plusFloat# a1 a2 = (GHC.Prim.plusFloat#) a1 a2-{-# NOINLINE minusFloat# #-}-minusFloat# :: Float# -> Float# -> Float#-minusFloat# a1 a2 = (GHC.Prim.minusFloat#) a1 a2-{-# NOINLINE timesFloat# #-}-timesFloat# :: Float# -> Float# -> Float#-timesFloat# a1 a2 = (GHC.Prim.timesFloat#) a1 a2-{-# NOINLINE divideFloat# #-}-divideFloat# :: Float# -> Float# -> Float#-divideFloat# a1 a2 = (GHC.Prim.divideFloat#) a1 a2-{-# NOINLINE negateFloat# #-}-negateFloat# :: Float# -> Float#-negateFloat# a1 = (GHC.Prim.negateFloat#) a1-{-# NOINLINE float2Int# #-}-float2Int# :: Float# -> Int#-float2Int# a1 = (GHC.Prim.float2Int#) a1-{-# NOINLINE expFloat# #-}-expFloat# :: Float# -> Float#-expFloat# a1 = (GHC.Prim.expFloat#) a1-{-# NOINLINE logFloat# #-}-logFloat# :: Float# -> Float#-logFloat# a1 = (GHC.Prim.logFloat#) a1-{-# NOINLINE sqrtFloat# #-}-sqrtFloat# :: Float# -> Float#-sqrtFloat# a1 = (GHC.Prim.sqrtFloat#) a1-{-# NOINLINE sinFloat# #-}-sinFloat# :: Float# -> Float#-sinFloat# a1 = (GHC.Prim.sinFloat#) a1-{-# NOINLINE cosFloat# #-}-cosFloat# :: Float# -> Float#-cosFloat# a1 = (GHC.Prim.cosFloat#) a1-{-# NOINLINE tanFloat# #-}-tanFloat# :: Float# -> Float#-tanFloat# a1 = (GHC.Prim.tanFloat#) a1-{-# NOINLINE asinFloat# #-}-asinFloat# :: Float# -> Float#-asinFloat# a1 = (GHC.Prim.asinFloat#) a1-{-# NOINLINE acosFloat# #-}-acosFloat# :: Float# -> Float#-acosFloat# a1 = (GHC.Prim.acosFloat#) a1-{-# NOINLINE atanFloat# #-}-atanFloat# :: Float# -> Float#-atanFloat# a1 = (GHC.Prim.atanFloat#) a1-{-# NOINLINE sinhFloat# #-}-sinhFloat# :: Float# -> Float#-sinhFloat# a1 = (GHC.Prim.sinhFloat#) a1-{-# NOINLINE coshFloat# #-}-coshFloat# :: Float# -> Float#-coshFloat# a1 = (GHC.Prim.coshFloat#) a1-{-# NOINLINE tanhFloat# #-}-tanhFloat# :: Float# -> Float#-tanhFloat# a1 = (GHC.Prim.tanhFloat#) a1-{-# NOINLINE powerFloat# #-}-powerFloat# :: Float# -> Float# -> Float#-powerFloat# a1 a2 = (GHC.Prim.powerFloat#) a1 a2-{-# NOINLINE float2Double# #-}-float2Double# :: Float# -> Double#-float2Double# a1 = (GHC.Prim.float2Double#) a1-{-# NOINLINE decodeFloat_Int# #-}-decodeFloat_Int# :: Float# -> (# Int#,Int# #)-decodeFloat_Int# a1 = (GHC.Prim.decodeFloat_Int#) a1-{-# NOINLINE newArray# #-}-newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)-newArray# a1 a2 a3 = (GHC.Prim.newArray#) a1 a2 a3-{-# NOINLINE sameMutableArray# #-}-sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#-sameMutableArray# a1 a2 = (GHC.Prim.sameMutableArray#) a1 a2-{-# NOINLINE readArray# #-}-readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)-readArray# a1 a2 a3 = (GHC.Prim.readArray#) a1 a2 a3-{-# NOINLINE writeArray# #-}-writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s-writeArray# a1 a2 a3 a4 = (GHC.Prim.writeArray#) a1 a2 a3 a4-{-# NOINLINE sizeofArray# #-}-sizeofArray# :: Array# a -> Int#-sizeofArray# a1 = (GHC.Prim.sizeofArray#) a1-{-# NOINLINE sizeofMutableArray# #-}-sizeofMutableArray# :: MutableArray# s a -> Int#-sizeofMutableArray# a1 = (GHC.Prim.sizeofMutableArray#) a1-{-# NOINLINE indexArray# #-}-indexArray# :: Array# a -> Int# -> (# a #)-indexArray# a1 a2 = (GHC.Prim.indexArray#) a1 a2-{-# NOINLINE unsafeFreezeArray# #-}-unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)-unsafeFreezeArray# a1 a2 = (GHC.Prim.unsafeFreezeArray#) a1 a2-{-# NOINLINE unsafeThawArray# #-}-unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)-unsafeThawArray# a1 a2 = (GHC.Prim.unsafeThawArray#) a1 a2-{-# NOINLINE copyArray# #-}-copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE copyMutableArray# #-}-copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE cloneArray# #-}-cloneArray# :: Array# a -> Int# -> Int# -> Array# a-cloneArray# a1 a2 a3 = (GHC.Prim.cloneArray#) a1 a2 a3-{-# NOINLINE cloneMutableArray# #-}-cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-cloneMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneMutableArray#) a1 a2 a3 a4-{-# NOINLINE freezeArray# #-}-freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)-freezeArray# a1 a2 a3 a4 = (GHC.Prim.freezeArray#) a1 a2 a3 a4-{-# NOINLINE thawArray# #-}-thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-thawArray# a1 a2 a3 a4 = (GHC.Prim.thawArray#) a1 a2 a3 a4-{-# NOINLINE casArray# #-}-casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)-casArray# a1 a2 a3 a4 a5 = (GHC.Prim.casArray#) a1 a2 a3 a4 a5-{-# NOINLINE newByteArray# #-}-newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2-{-# NOINLINE newPinnedByteArray# #-}-newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newPinnedByteArray# a1 a2 = (GHC.Prim.newPinnedByteArray#) a1 a2-{-# NOINLINE newAlignedPinnedByteArray# #-}-newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-newAlignedPinnedByteArray# a1 a2 a3 = (GHC.Prim.newAlignedPinnedByteArray#) a1 a2 a3-{-# NOINLINE byteArrayContents# #-}-byteArrayContents# :: ByteArray# -> Addr#-byteArrayContents# a1 = (GHC.Prim.byteArrayContents#) a1-{-# NOINLINE sameMutableByteArray# #-}-sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#-sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2-{-# NOINLINE unsafeFreezeByteArray# #-}-unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)-unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2-{-# NOINLINE sizeofByteArray# #-}-sizeofByteArray# :: ByteArray# -> Int#-sizeofByteArray# a1 = (GHC.Prim.sizeofByteArray#) a1-{-# NOINLINE sizeofMutableByteArray# #-}-sizeofMutableByteArray# :: MutableByteArray# s -> Int#-sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1-{-# NOINLINE indexCharArray# #-}-indexCharArray# :: ByteArray# -> Int# -> Char#-indexCharArray# a1 a2 = (GHC.Prim.indexCharArray#) a1 a2-{-# NOINLINE indexWideCharArray# #-}-indexWideCharArray# :: ByteArray# -> Int# -> Char#-indexWideCharArray# a1 a2 = (GHC.Prim.indexWideCharArray#) a1 a2-{-# NOINLINE indexIntArray# #-}-indexIntArray# :: ByteArray# -> Int# -> Int#-indexIntArray# a1 a2 = (GHC.Prim.indexIntArray#) a1 a2-{-# NOINLINE indexWordArray# #-}-indexWordArray# :: ByteArray# -> Int# -> Word#-indexWordArray# a1 a2 = (GHC.Prim.indexWordArray#) a1 a2-{-# NOINLINE indexAddrArray# #-}-indexAddrArray# :: ByteArray# -> Int# -> Addr#-indexAddrArray# a1 a2 = (GHC.Prim.indexAddrArray#) a1 a2-{-# NOINLINE indexFloatArray# #-}-indexFloatArray# :: ByteArray# -> Int# -> Float#-indexFloatArray# a1 a2 = (GHC.Prim.indexFloatArray#) a1 a2-{-# NOINLINE indexDoubleArray# #-}-indexDoubleArray# :: ByteArray# -> Int# -> Double#-indexDoubleArray# a1 a2 = (GHC.Prim.indexDoubleArray#) a1 a2-{-# NOINLINE indexStablePtrArray# #-}-indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a-indexStablePtrArray# a1 a2 = (GHC.Prim.indexStablePtrArray#) a1 a2-{-# NOINLINE indexInt8Array# #-}-indexInt8Array# :: ByteArray# -> Int# -> Int#-indexInt8Array# a1 a2 = (GHC.Prim.indexInt8Array#) a1 a2-{-# NOINLINE indexInt16Array# #-}-indexInt16Array# :: ByteArray# -> Int# -> Int#-indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2-{-# NOINLINE indexInt32Array# #-}-indexInt32Array# :: ByteArray# -> Int# -> Int#-indexInt32Array# a1 a2 = (GHC.Prim.indexInt32Array#) a1 a2-{-# NOINLINE indexInt64Array# #-}-indexInt64Array# :: ByteArray# -> Int# -> Int#-indexInt64Array# a1 a2 = (GHC.Prim.indexInt64Array#) a1 a2-{-# NOINLINE indexWord8Array# #-}-indexWord8Array# :: ByteArray# -> Int# -> Word#-indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2-{-# NOINLINE indexWord16Array# #-}-indexWord16Array# :: ByteArray# -> Int# -> Word#-indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2-{-# NOINLINE indexWord32Array# #-}-indexWord32Array# :: ByteArray# -> Int# -> Word#-indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2-{-# NOINLINE indexWord64Array# #-}-indexWord64Array# :: ByteArray# -> Int# -> Word#-indexWord64Array# a1 a2 = (GHC.Prim.indexWord64Array#) a1 a2-{-# NOINLINE readCharArray# #-}-readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readCharArray# a1 a2 a3 = (GHC.Prim.readCharArray#) a1 a2 a3-{-# NOINLINE readWideCharArray# #-}-readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readWideCharArray# a1 a2 a3 = (GHC.Prim.readWideCharArray#) a1 a2 a3-{-# NOINLINE readIntArray# #-}-readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readIntArray# a1 a2 a3 = (GHC.Prim.readIntArray#) a1 a2 a3-{-# NOINLINE readWordArray# #-}-readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWordArray# a1 a2 a3 = (GHC.Prim.readWordArray#) a1 a2 a3-{-# NOINLINE readAddrArray# #-}-readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)-readAddrArray# a1 a2 a3 = (GHC.Prim.readAddrArray#) a1 a2 a3-{-# NOINLINE readFloatArray# #-}-readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)-readFloatArray# a1 a2 a3 = (GHC.Prim.readFloatArray#) a1 a2 a3-{-# NOINLINE readDoubleArray# #-}-readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)-readDoubleArray# a1 a2 a3 = (GHC.Prim.readDoubleArray#) a1 a2 a3-{-# NOINLINE readStablePtrArray# #-}-readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrArray# a1 a2 a3 = (GHC.Prim.readStablePtrArray#) a1 a2 a3-{-# NOINLINE readInt8Array# #-}-readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt8Array# a1 a2 a3 = (GHC.Prim.readInt8Array#) a1 a2 a3-{-# NOINLINE readInt16Array# #-}-readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt16Array# a1 a2 a3 = (GHC.Prim.readInt16Array#) a1 a2 a3-{-# NOINLINE readInt32Array# #-}-readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt32Array# a1 a2 a3 = (GHC.Prim.readInt32Array#) a1 a2 a3-{-# NOINLINE readInt64Array# #-}-readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt64Array# a1 a2 a3 = (GHC.Prim.readInt64Array#) a1 a2 a3-{-# NOINLINE readWord8Array# #-}-readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord8Array# a1 a2 a3 = (GHC.Prim.readWord8Array#) a1 a2 a3-{-# NOINLINE readWord16Array# #-}-readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord16Array# a1 a2 a3 = (GHC.Prim.readWord16Array#) a1 a2 a3-{-# NOINLINE readWord32Array# #-}-readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord32Array# a1 a2 a3 = (GHC.Prim.readWord32Array#) a1 a2 a3-{-# NOINLINE readWord64Array# #-}-readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord64Array# a1 a2 a3 = (GHC.Prim.readWord64Array#) a1 a2 a3-{-# NOINLINE writeCharArray# #-}-writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeCharArray# a1 a2 a3 a4 = (GHC.Prim.writeCharArray#) a1 a2 a3 a4-{-# NOINLINE writeWideCharArray# #-}-writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeWideCharArray# a1 a2 a3 a4 = (GHC.Prim.writeWideCharArray#) a1 a2 a3 a4-{-# NOINLINE writeIntArray# #-}-writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeIntArray# a1 a2 a3 a4 = (GHC.Prim.writeIntArray#) a1 a2 a3 a4-{-# NOINLINE writeWordArray# #-}-writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWordArray# a1 a2 a3 a4 = (GHC.Prim.writeWordArray#) a1 a2 a3 a4-{-# NOINLINE writeAddrArray# #-}-writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s-writeAddrArray# a1 a2 a3 a4 = (GHC.Prim.writeAddrArray#) a1 a2 a3 a4-{-# NOINLINE writeFloatArray# #-}-writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s-writeFloatArray# a1 a2 a3 a4 = (GHC.Prim.writeFloatArray#) a1 a2 a3 a4-{-# NOINLINE writeDoubleArray# #-}-writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s-writeDoubleArray# a1 a2 a3 a4 = (GHC.Prim.writeDoubleArray#) a1 a2 a3 a4-{-# NOINLINE writeStablePtrArray# #-}-writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrArray# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrArray#) a1 a2 a3 a4-{-# NOINLINE writeInt8Array# #-}-writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt8Array# a1 a2 a3 a4 = (GHC.Prim.writeInt8Array#) a1 a2 a3 a4-{-# NOINLINE writeInt16Array# #-}-writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt16Array# a1 a2 a3 a4 = (GHC.Prim.writeInt16Array#) a1 a2 a3 a4-{-# NOINLINE writeInt32Array# #-}-writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt32Array# a1 a2 a3 a4 = (GHC.Prim.writeInt32Array#) a1 a2 a3 a4-{-# NOINLINE writeInt64Array# #-}-writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt64Array# a1 a2 a3 a4 = (GHC.Prim.writeInt64Array#) a1 a2 a3 a4-{-# NOINLINE writeWord8Array# #-}-writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord8Array# a1 a2 a3 a4 = (GHC.Prim.writeWord8Array#) a1 a2 a3 a4-{-# NOINLINE writeWord16Array# #-}-writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord16Array# a1 a2 a3 a4 = (GHC.Prim.writeWord16Array#) a1 a2 a3 a4-{-# NOINLINE writeWord32Array# #-}-writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord32Array# a1 a2 a3 a4 = (GHC.Prim.writeWord32Array#) a1 a2 a3 a4-{-# NOINLINE writeWord64Array# #-}-writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord64Array# a1 a2 a3 a4 = (GHC.Prim.writeWord64Array#) a1 a2 a3 a4-{-# NOINLINE copyByteArray# #-}-copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyByteArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE copyMutableByteArray# #-}-copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableByteArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE copyByteArrayToAddr# #-}-copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s-copyByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyByteArrayToAddr#) a1 a2 a3 a4 a5-{-# NOINLINE copyMutableByteArrayToAddr# #-}-copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s-copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyMutableByteArrayToAddr#) a1 a2 a3 a4 a5-{-# NOINLINE copyAddrToByteArray# #-}-copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyAddrToByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.copyAddrToByteArray#) a1 a2 a3 a4 a5-{-# NOINLINE setByteArray# #-}-setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s-setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5-{-# NOINLINE casIntArray# #-}-casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)-casIntArray# a1 a2 a3 a4 a5 = (GHC.Prim.casIntArray#) a1 a2 a3 a4 a5-{-# NOINLINE fetchAddIntArray# #-}-fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchAddIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAddIntArray#) a1 a2 a3 a4-{-# NOINLINE newArrayArray# #-}-newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)-newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2-{-# NOINLINE sameMutableArrayArray# #-}-sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#-sameMutableArrayArray# a1 a2 = (GHC.Prim.sameMutableArrayArray#) a1 a2-{-# NOINLINE unsafeFreezeArrayArray# #-}-unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)-unsafeFreezeArrayArray# a1 a2 = (GHC.Prim.unsafeFreezeArrayArray#) a1 a2-{-# NOINLINE sizeofArrayArray# #-}-sizeofArrayArray# :: ArrayArray# -> Int#-sizeofArrayArray# a1 = (GHC.Prim.sizeofArrayArray#) a1-{-# NOINLINE sizeofMutableArrayArray# #-}-sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#-sizeofMutableArrayArray# a1 = (GHC.Prim.sizeofMutableArrayArray#) a1-{-# NOINLINE indexByteArrayArray# #-}-indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#-indexByteArrayArray# a1 a2 = (GHC.Prim.indexByteArrayArray#) a1 a2-{-# NOINLINE indexArrayArrayArray# #-}-indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#-indexArrayArrayArray# a1 a2 = (GHC.Prim.indexArrayArrayArray#) a1 a2-{-# NOINLINE readByteArrayArray# #-}-readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)-readByteArrayArray# a1 a2 a3 = (GHC.Prim.readByteArrayArray#) a1 a2 a3-{-# NOINLINE readMutableByteArrayArray# #-}-readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-readMutableByteArrayArray# a1 a2 a3 = (GHC.Prim.readMutableByteArrayArray#) a1 a2 a3-{-# NOINLINE readArrayArrayArray# #-}-readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)-readArrayArrayArray# a1 a2 a3 = (GHC.Prim.readArrayArrayArray#) a1 a2 a3-{-# NOINLINE readMutableArrayArrayArray# #-}-readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)-readMutableArrayArrayArray# a1 a2 a3 = (GHC.Prim.readMutableArrayArrayArray#) a1 a2 a3-{-# NOINLINE writeByteArrayArray# #-}-writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s-writeByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeByteArrayArray#) a1 a2 a3 a4-{-# NOINLINE writeMutableByteArrayArray# #-}-writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s-writeMutableByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableByteArrayArray#) a1 a2 a3 a4-{-# NOINLINE writeArrayArrayArray# #-}-writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s-writeArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeArrayArrayArray#) a1 a2 a3 a4-{-# NOINLINE writeMutableArrayArrayArray# #-}-writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s-writeMutableArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableArrayArrayArray#) a1 a2 a3 a4-{-# NOINLINE copyArrayArray# #-}-copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArrayArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE copyMutableArrayArray# #-}-copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArrayArray#) a1 a2 a3 a4 a5 a6-{-# NOINLINE plusAddr# #-}-plusAddr# :: Addr# -> Int# -> Addr#-plusAddr# a1 a2 = (GHC.Prim.plusAddr#) a1 a2-{-# NOINLINE minusAddr# #-}-minusAddr# :: Addr# -> Addr# -> Int#-minusAddr# a1 a2 = (GHC.Prim.minusAddr#) a1 a2-{-# NOINLINE remAddr# #-}-remAddr# :: Addr# -> Int# -> Int#-remAddr# a1 a2 = (GHC.Prim.remAddr#) a1 a2-{-# NOINLINE addr2Int# #-}-addr2Int# :: Addr# -> Int#-addr2Int# a1 = (GHC.Prim.addr2Int#) a1-{-# NOINLINE int2Addr# #-}-int2Addr# :: Int# -> Addr#-int2Addr# a1 = (GHC.Prim.int2Addr#) a1-{-# NOINLINE gtAddr# #-}-gtAddr# :: Addr# -> Addr# -> Int#-gtAddr# a1 a2 = (GHC.Prim.gtAddr#) a1 a2-{-# NOINLINE geAddr# #-}-geAddr# :: Addr# -> Addr# -> Int#-geAddr# a1 a2 = (GHC.Prim.geAddr#) a1 a2-{-# NOINLINE eqAddr# #-}-eqAddr# :: Addr# -> Addr# -> Int#-eqAddr# a1 a2 = (GHC.Prim.eqAddr#) a1 a2-{-# NOINLINE neAddr# #-}-neAddr# :: Addr# -> Addr# -> Int#-neAddr# a1 a2 = (GHC.Prim.neAddr#) a1 a2-{-# NOINLINE ltAddr# #-}-ltAddr# :: Addr# -> Addr# -> Int#-ltAddr# a1 a2 = (GHC.Prim.ltAddr#) a1 a2-{-# NOINLINE leAddr# #-}-leAddr# :: Addr# -> Addr# -> Int#-leAddr# a1 a2 = (GHC.Prim.leAddr#) a1 a2-{-# NOINLINE indexCharOffAddr# #-}-indexCharOffAddr# :: Addr# -> Int# -> Char#-indexCharOffAddr# a1 a2 = (GHC.Prim.indexCharOffAddr#) a1 a2-{-# NOINLINE indexWideCharOffAddr# #-}-indexWideCharOffAddr# :: Addr# -> Int# -> Char#-indexWideCharOffAddr# a1 a2 = (GHC.Prim.indexWideCharOffAddr#) a1 a2-{-# NOINLINE indexIntOffAddr# #-}-indexIntOffAddr# :: Addr# -> Int# -> Int#-indexIntOffAddr# a1 a2 = (GHC.Prim.indexIntOffAddr#) a1 a2-{-# NOINLINE indexWordOffAddr# #-}-indexWordOffAddr# :: Addr# -> Int# -> Word#-indexWordOffAddr# a1 a2 = (GHC.Prim.indexWordOffAddr#) a1 a2-{-# NOINLINE indexAddrOffAddr# #-}-indexAddrOffAddr# :: Addr# -> Int# -> Addr#-indexAddrOffAddr# a1 a2 = (GHC.Prim.indexAddrOffAddr#) a1 a2-{-# NOINLINE indexFloatOffAddr# #-}-indexFloatOffAddr# :: Addr# -> Int# -> Float#-indexFloatOffAddr# a1 a2 = (GHC.Prim.indexFloatOffAddr#) a1 a2-{-# NOINLINE indexDoubleOffAddr# #-}-indexDoubleOffAddr# :: Addr# -> Int# -> Double#-indexDoubleOffAddr# a1 a2 = (GHC.Prim.indexDoubleOffAddr#) a1 a2-{-# NOINLINE indexStablePtrOffAddr# #-}-indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a-indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2-{-# NOINLINE indexInt8OffAddr# #-}-indexInt8OffAddr# :: Addr# -> Int# -> Int#-indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2-{-# NOINLINE indexInt16OffAddr# #-}-indexInt16OffAddr# :: Addr# -> Int# -> Int#-indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2-{-# NOINLINE indexInt32OffAddr# #-}-indexInt32OffAddr# :: Addr# -> Int# -> Int#-indexInt32OffAddr# a1 a2 = (GHC.Prim.indexInt32OffAddr#) a1 a2-{-# NOINLINE indexInt64OffAddr# #-}-indexInt64OffAddr# :: Addr# -> Int# -> Int#-indexInt64OffAddr# a1 a2 = (GHC.Prim.indexInt64OffAddr#) a1 a2-{-# NOINLINE indexWord8OffAddr# #-}-indexWord8OffAddr# :: Addr# -> Int# -> Word#-indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2-{-# NOINLINE indexWord16OffAddr# #-}-indexWord16OffAddr# :: Addr# -> Int# -> Word#-indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2-{-# NOINLINE indexWord32OffAddr# #-}-indexWord32OffAddr# :: Addr# -> Int# -> Word#-indexWord32OffAddr# a1 a2 = (GHC.Prim.indexWord32OffAddr#) a1 a2-{-# NOINLINE indexWord64OffAddr# #-}-indexWord64OffAddr# :: Addr# -> Int# -> Word#-indexWord64OffAddr# a1 a2 = (GHC.Prim.indexWord64OffAddr#) a1 a2-{-# NOINLINE readCharOffAddr# #-}-readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readCharOffAddr# a1 a2 a3 = (GHC.Prim.readCharOffAddr#) a1 a2 a3-{-# NOINLINE readWideCharOffAddr# #-}-readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readWideCharOffAddr# a1 a2 a3 = (GHC.Prim.readWideCharOffAddr#) a1 a2 a3-{-# NOINLINE readIntOffAddr# #-}-readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readIntOffAddr# a1 a2 a3 = (GHC.Prim.readIntOffAddr#) a1 a2 a3-{-# NOINLINE readWordOffAddr# #-}-readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWordOffAddr# a1 a2 a3 = (GHC.Prim.readWordOffAddr#) a1 a2 a3-{-# NOINLINE readAddrOffAddr# #-}-readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)-readAddrOffAddr# a1 a2 a3 = (GHC.Prim.readAddrOffAddr#) a1 a2 a3-{-# NOINLINE readFloatOffAddr# #-}-readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)-readFloatOffAddr# a1 a2 a3 = (GHC.Prim.readFloatOffAddr#) a1 a2 a3-{-# NOINLINE readDoubleOffAddr# #-}-readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)-readDoubleOffAddr# a1 a2 a3 = (GHC.Prim.readDoubleOffAddr#) a1 a2 a3-{-# NOINLINE readStablePtrOffAddr# #-}-readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrOffAddr# a1 a2 a3 = (GHC.Prim.readStablePtrOffAddr#) a1 a2 a3-{-# NOINLINE readInt8OffAddr# #-}-readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt8OffAddr# a1 a2 a3 = (GHC.Prim.readInt8OffAddr#) a1 a2 a3-{-# NOINLINE readInt16OffAddr# #-}-readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt16OffAddr# a1 a2 a3 = (GHC.Prim.readInt16OffAddr#) a1 a2 a3-{-# NOINLINE readInt32OffAddr# #-}-readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt32OffAddr# a1 a2 a3 = (GHC.Prim.readInt32OffAddr#) a1 a2 a3-{-# NOINLINE readInt64OffAddr# #-}-readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt64OffAddr# a1 a2 a3 = (GHC.Prim.readInt64OffAddr#) a1 a2 a3-{-# NOINLINE readWord8OffAddr# #-}-readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord8OffAddr# a1 a2 a3 = (GHC.Prim.readWord8OffAddr#) a1 a2 a3-{-# NOINLINE readWord16OffAddr# #-}-readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord16OffAddr# a1 a2 a3 = (GHC.Prim.readWord16OffAddr#) a1 a2 a3-{-# NOINLINE readWord32OffAddr# #-}-readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord32OffAddr# a1 a2 a3 = (GHC.Prim.readWord32OffAddr#) a1 a2 a3-{-# NOINLINE readWord64OffAddr# #-}-readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord64OffAddr# a1 a2 a3 = (GHC.Prim.readWord64OffAddr#) a1 a2 a3-{-# NOINLINE writeCharOffAddr# #-}-writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeCharOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWideCharOffAddr# #-}-writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeWideCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWideCharOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeIntOffAddr# #-}-writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeIntOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeIntOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWordOffAddr# #-}-writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWordOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWordOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeAddrOffAddr# #-}-writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s-writeAddrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeAddrOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeFloatOffAddr# #-}-writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s-writeFloatOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeFloatOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeDoubleOffAddr# #-}-writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s-writeDoubleOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeDoubleOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeStablePtrOffAddr# #-}-writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrOffAddr#) a1 a2 a3 a4-{-# NOINLINE writeInt8OffAddr# #-}-writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeInt16OffAddr# #-}-writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt16OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeInt32OffAddr# #-}-writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt32OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeInt64OffAddr# #-}-writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt64OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWord8OffAddr# #-}-writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord8OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWord16OffAddr# #-}-writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord16OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWord32OffAddr# #-}-writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord32OffAddr#) a1 a2 a3 a4-{-# NOINLINE writeWord64OffAddr# #-}-writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord64OffAddr#) a1 a2 a3 a4-{-# NOINLINE newMutVar# #-}-newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)-newMutVar# a1 a2 = (GHC.Prim.newMutVar#) a1 a2-{-# NOINLINE readMutVar# #-}-readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)-readMutVar# a1 a2 = (GHC.Prim.readMutVar#) a1 a2-{-# NOINLINE writeMutVar# #-}-writeMutVar# :: MutVar# s a -> a -> State# s -> State# s-writeMutVar# a1 a2 a3 = (GHC.Prim.writeMutVar#) a1 a2 a3-{-# NOINLINE sameMutVar# #-}-sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#-sameMutVar# a1 a2 = (GHC.Prim.sameMutVar#) a1 a2-{-# NOINLINE atomicModifyMutVar# #-}-atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)-atomicModifyMutVar# a1 a2 a3 = (GHC.Prim.atomicModifyMutVar#) a1 a2 a3-{-# NOINLINE casMutVar# #-}-casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)-casMutVar# a1 a2 a3 a4 = (GHC.Prim.casMutVar#) a1 a2 a3 a4-{-# NOINLINE catch# #-}-catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catch# a1 a2 a3 = (GHC.Prim.catch#) a1 a2 a3-{-# NOINLINE raise# #-}-raise# :: a -> b-raise# a1 = (GHC.Prim.raise#) a1-{-# NOINLINE raiseIO# #-}-raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)-raiseIO# a1 a2 = (GHC.Prim.raiseIO#) a1 a2-{-# NOINLINE maskAsyncExceptions# #-}-maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskAsyncExceptions# a1 a2 = (GHC.Prim.maskAsyncExceptions#) a1 a2-{-# NOINLINE maskUninterruptible# #-}-maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskUninterruptible# a1 a2 = (GHC.Prim.maskUninterruptible#) a1 a2-{-# NOINLINE unmaskAsyncExceptions# #-}-unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-unmaskAsyncExceptions# a1 a2 = (GHC.Prim.unmaskAsyncExceptions#) a1 a2-{-# NOINLINE getMaskingState# #-}-getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-getMaskingState# a1 = (GHC.Prim.getMaskingState#) a1-{-# NOINLINE atomically# #-}-atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-atomically# a1 a2 = (GHC.Prim.atomically#) a1 a2-{-# NOINLINE retry# #-}-retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)-retry# a1 = (GHC.Prim.retry#) a1-{-# NOINLINE catchRetry# #-}-catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchRetry# a1 a2 a3 = (GHC.Prim.catchRetry#) a1 a2 a3-{-# NOINLINE catchSTM# #-}-catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchSTM# a1 a2 a3 = (GHC.Prim.catchSTM#) a1 a2 a3-{-# NOINLINE check# #-}-check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)-check# a1 a2 = (GHC.Prim.check#) a1 a2-{-# NOINLINE newTVar# #-}-newTVar# :: a -> State# s -> (# State# s,TVar# s a #)-newTVar# a1 a2 = (GHC.Prim.newTVar#) a1 a2-{-# NOINLINE readTVar# #-}-readTVar# :: TVar# s a -> State# s -> (# State# s,a #)-readTVar# a1 a2 = (GHC.Prim.readTVar#) a1 a2-{-# NOINLINE readTVarIO# #-}-readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)-readTVarIO# a1 a2 = (GHC.Prim.readTVarIO#) a1 a2-{-# NOINLINE writeTVar# #-}-writeTVar# :: TVar# s a -> a -> State# s -> State# s-writeTVar# a1 a2 a3 = (GHC.Prim.writeTVar#) a1 a2 a3-{-# NOINLINE sameTVar# #-}-sameTVar# :: TVar# s a -> TVar# s a -> Int#-sameTVar# a1 a2 = (GHC.Prim.sameTVar#) a1 a2-{-# NOINLINE newMVar# #-}-newMVar# :: State# s -> (# State# s,MVar# s a #)-newMVar# a1 = (GHC.Prim.newMVar#) a1-{-# NOINLINE takeMVar# #-}-takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)-takeMVar# a1 a2 = (GHC.Prim.takeMVar#) a1 a2-{-# NOINLINE tryTakeMVar# #-}-tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryTakeMVar# a1 a2 = (GHC.Prim.tryTakeMVar#) a1 a2-{-# NOINLINE putMVar# #-}-putMVar# :: MVar# s a -> a -> State# s -> State# s-putMVar# a1 a2 a3 = (GHC.Prim.putMVar#) a1 a2 a3-{-# NOINLINE tryPutMVar# #-}-tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)-tryPutMVar# a1 a2 a3 = (GHC.Prim.tryPutMVar#) a1 a2 a3-{-# NOINLINE readMVar# #-}-readMVar# :: MVar# s a -> State# s -> (# State# s,a #)-readMVar# a1 a2 = (GHC.Prim.readMVar#) a1 a2-{-# NOINLINE tryReadMVar# #-}-tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryReadMVar# a1 a2 = (GHC.Prim.tryReadMVar#) a1 a2-{-# NOINLINE sameMVar# #-}-sameMVar# :: MVar# s a -> MVar# s a -> Int#-sameMVar# a1 a2 = (GHC.Prim.sameMVar#) a1 a2-{-# NOINLINE isEmptyMVar# #-}-isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)-isEmptyMVar# a1 a2 = (GHC.Prim.isEmptyMVar#) a1 a2-{-# NOINLINE delay# #-}-delay# :: Int# -> State# s -> State# s-delay# a1 a2 = (GHC.Prim.delay#) a1 a2-{-# NOINLINE waitRead# #-}-waitRead# :: Int# -> State# s -> State# s-waitRead# a1 a2 = (GHC.Prim.waitRead#) a1 a2-{-# NOINLINE waitWrite# #-}-waitWrite# :: Int# -> State# s -> State# s-waitWrite# a1 a2 = (GHC.Prim.waitWrite#) a1 a2-{-# NOINLINE fork# #-}-fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-fork# a1 a2 = (GHC.Prim.fork#) a1 a2-{-# NOINLINE forkOn# #-}-forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-forkOn# a1 a2 a3 = (GHC.Prim.forkOn#) a1 a2 a3-{-# NOINLINE killThread# #-}-killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)-killThread# a1 a2 a3 = (GHC.Prim.killThread#) a1 a2 a3-{-# NOINLINE yield# #-}-yield# :: State# (RealWorld) -> State# (RealWorld)-yield# a1 = (GHC.Prim.yield#) a1-{-# NOINLINE myThreadId# #-}-myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-myThreadId# a1 = (GHC.Prim.myThreadId#) a1-{-# NOINLINE labelThread# #-}-labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)-labelThread# a1 a2 a3 = (GHC.Prim.labelThread#) a1 a2 a3-{-# NOINLINE isCurrentThreadBound# #-}-isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-isCurrentThreadBound# a1 = (GHC.Prim.isCurrentThreadBound#) a1-{-# NOINLINE noDuplicate# #-}-noDuplicate# :: State# (RealWorld) -> State# (RealWorld)-noDuplicate# a1 = (GHC.Prim.noDuplicate#) a1-{-# NOINLINE threadStatus# #-}-threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)-threadStatus# a1 a2 = (GHC.Prim.threadStatus#) a1 a2-{-# NOINLINE mkWeak# #-}-mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeak# a1 a2 a3 a4 = (GHC.Prim.mkWeak#) a1 a2 a3 a4-{-# NOINLINE mkWeakNoFinalizer# #-}-mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeakNoFinalizer# a1 a2 a3 = (GHC.Prim.mkWeakNoFinalizer#) a1 a2 a3-{-# NOINLINE addCFinalizerToWeak# #-}-addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)-addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = (GHC.Prim.addCFinalizerToWeak#) a1 a2 a3 a4 a5 a6-{-# NOINLINE deRefWeak# #-}-deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)-deRefWeak# a1 a2 = (GHC.Prim.deRefWeak#) a1 a2-{-# NOINLINE finalizeWeak# #-}-finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)-finalizeWeak# a1 a2 = (GHC.Prim.finalizeWeak#) a1 a2-{-# NOINLINE touch# #-}-touch# :: o -> State# (RealWorld) -> State# (RealWorld)-touch# a1 a2 = (GHC.Prim.touch#) a1 a2-{-# NOINLINE makeStablePtr# #-}-makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)-makeStablePtr# a1 a2 = (GHC.Prim.makeStablePtr#) a1 a2-{-# NOINLINE deRefStablePtr# #-}-deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)-deRefStablePtr# a1 a2 = (GHC.Prim.deRefStablePtr#) a1 a2-{-# NOINLINE eqStablePtr# #-}-eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#-eqStablePtr# a1 a2 = (GHC.Prim.eqStablePtr#) a1 a2-{-# NOINLINE makeStableName# #-}-makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)-makeStableName# a1 a2 = (GHC.Prim.makeStableName#) a1 a2-{-# NOINLINE eqStableName# #-}-eqStableName# :: StableName# a -> StableName# b -> Int#-eqStableName# a1 a2 = (GHC.Prim.eqStableName#) a1 a2-{-# NOINLINE stableNameToInt# #-}-stableNameToInt# :: StableName# a -> Int#-stableNameToInt# a1 = (GHC.Prim.stableNameToInt#) a1-{-# NOINLINE reallyUnsafePtrEquality# #-}-reallyUnsafePtrEquality# :: a -> a -> Int#-reallyUnsafePtrEquality# a1 a2 = (GHC.Prim.reallyUnsafePtrEquality#) a1 a2-{-# NOINLINE spark# #-}-spark# :: a -> State# s -> (# State# s,a #)-spark# a1 a2 = (GHC.Prim.spark#) a1 a2-{-# NOINLINE getSpark# #-}-getSpark# :: State# s -> (# State# s,Int#,a #)-getSpark# a1 = (GHC.Prim.getSpark#) a1-{-# NOINLINE numSparks# #-}-numSparks# :: State# s -> (# State# s,Int# #)-numSparks# a1 = (GHC.Prim.numSparks#) a1-{-# NOINLINE dataToTag# #-}-dataToTag# :: a -> Int#-dataToTag# a1 = (GHC.Prim.dataToTag#) a1-{-# NOINLINE addrToAny# #-}-addrToAny# :: Addr# -> (# a #)-addrToAny# a1 = (GHC.Prim.addrToAny#) a1-{-# NOINLINE mkApUpd0# #-}-mkApUpd0# :: BCO# -> (# a #)-mkApUpd0# a1 = (GHC.Prim.mkApUpd0#) a1-{-# NOINLINE newBCO# #-}-newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)-newBCO# a1 a2 a3 a4 a5 a6 = (GHC.Prim.newBCO#) a1 a2 a3 a4 a5 a6-{-# NOINLINE unpackClosure# #-}-unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)-unpackClosure# a1 = (GHC.Prim.unpackClosure#) a1-{-# NOINLINE getApStackVal# #-}-getApStackVal# :: a -> Int# -> (# Int#,b #)-getApStackVal# a1 a2 = (GHC.Prim.getApStackVal#) a1 a2-{-# NOINLINE getCCSOf# #-}-getCCSOf# :: a -> State# s -> (# State# s,Addr# #)-getCCSOf# a1 a2 = (GHC.Prim.getCCSOf#) a1 a2-{-# NOINLINE getCurrentCCS# #-}-getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)-getCurrentCCS# a1 a2 = (GHC.Prim.getCurrentCCS#) a1 a2-{-# NOINLINE traceEvent# #-}-traceEvent# :: Addr# -> State# s -> State# s-traceEvent# a1 a2 = (GHC.Prim.traceEvent#) a1 a2-{-# NOINLINE traceMarker# #-}-traceMarker# :: Addr# -> State# s -> State# s-traceMarker# a1 a2 = (GHC.Prim.traceMarker#) a1 a2-{-# NOINLINE prefetchByteArray3# #-}-prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray3# a1 a2 = (GHC.Prim.prefetchByteArray3#) a1 a2-{-# NOINLINE prefetchMutableByteArray3# #-}-prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray3# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray3#) a1 a2 a3-{-# NOINLINE prefetchAddr3# #-}-prefetchAddr3# :: Addr# -> Int# -> Addr#-prefetchAddr3# a1 a2 = (GHC.Prim.prefetchAddr3#) a1 a2-{-# NOINLINE prefetchByteArray2# #-}-prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray2# a1 a2 = (GHC.Prim.prefetchByteArray2#) a1 a2-{-# NOINLINE prefetchMutableByteArray2# #-}-prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray2# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray2#) a1 a2 a3-{-# NOINLINE prefetchAddr2# #-}-prefetchAddr2# :: Addr# -> Int# -> Addr#-prefetchAddr2# a1 a2 = (GHC.Prim.prefetchAddr2#) a1 a2-{-# NOINLINE prefetchByteArray1# #-}-prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray1# a1 a2 = (GHC.Prim.prefetchByteArray1#) a1 a2-{-# NOINLINE prefetchMutableByteArray1# #-}-prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray1# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray1#) a1 a2 a3-{-# NOINLINE prefetchAddr1# #-}-prefetchAddr1# :: Addr# -> Int# -> Addr#-prefetchAddr1# a1 a2 = (GHC.Prim.prefetchAddr1#) a1 a2-{-# NOINLINE prefetchByteArray0# #-}-prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray0# a1 a2 = (GHC.Prim.prefetchByteArray0#) a1 a2-{-# NOINLINE prefetchMutableByteArray0# #-}-prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray0# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray0#) a1 a2 a3-{-# NOINLINE prefetchAddr0# #-}-prefetchAddr0# :: Addr# -> Int# -> Addr#-prefetchAddr0# a1 a2 = (GHC.Prim.prefetchAddr0#) a1 a2+-- | 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
GHC/Tuple.hs view
@@ -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)
GHC/Types.hs view
@@ -1,212 +1,3677 @@-{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples #-}--------------------------------------------------------------------------------- |--- Module      :  GHC.Types--- Copyright   :  (c) The University of Glasgow 2009--- License     :  see libraries/ghc-prim/LICENSE------ Maintainer  :  cvs-ghc@haskell.org--- Stability   :  internal--- Portability :  non-portable (GHC Extensions)------ GHC type definitions.--- Use GHC.Exts from the base package instead of importing this--- module directly.-----------------------------------------------------------------------------------module GHC.Types (-        Bool(..), Char(..), Int(..), Word(..),-        Float(..), Double(..),-        Ordering(..), IO(..),-        isTrue#,-        SPEC(..)-    ) where--import GHC.Prim---infixr 5 :--data [] a = [] | a : [a]--data {-# CTYPE "HsBool" #-} Bool = False | True--{- | The character type 'Char' is an enumeration whose values represent-Unicode (or equivalently ISO\/IEC 10646) characters (see-<http://www.unicode.org/> for details).  This set extends the ISO 8859-1-(Latin-1) character set (the first 256 characters), which is itself an extension-of the ASCII character set (the first 128 characters).  A character literal in-Haskell has type 'Char'.--To convert a 'Char' to or from the corresponding 'Int' value defined-by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the-'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr').--}-data {-# CTYPE "HsChar" #-} Char = C# Char#---- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.--- The exact range for a given implementation can be determined by using--- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.-data {-# CTYPE "HsInt" #-} Int = I# Int#---- |A 'Word' is an unsigned integral type, with the same size as 'Int'.-data {-# CTYPE "HsWord" #-} Word = W# Word#---- | Single-precision floating point numbers.--- It is desirable that this type be at least equal in range and precision--- to the IEEE single-precision type.-data {-# CTYPE "HsFloat" #-} Float = F# Float#---- | Double-precision floating point numbers.--- It is desirable that this type be at least equal in range and precision--- to the IEEE double-precision type.-data {-# CTYPE "HsDouble" #-} Double = D# Double#--data Ordering = LT | EQ | GT--{- |-A value of type @'IO' a@ is a computation which, when performed,-does some I\/O before returning a value of type @a@.--There is really only one way to \"perform\" an I\/O action: bind it to-@Main.main@ in your program.  When your program is run, the I\/O will-be performed.  It isn't possible to perform I\/O from an arbitrary-function, unless that function is itself in the 'IO' monad and called-at some point, directly or indirectly, from @Main.main@.--'IO' is a monad, so 'IO' actions can be combined using either the do-notation-or the '>>' and '>>=' operations from the 'Monad' class.--}-newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))----- | A data constructor used to box up all unlifted equalities------ The type constructor is special in that GHC pretends that it--- has kind (? -> ? -> Fact) rather than (* -> * -> *)-data (~) a b = Eq# ((~#) a b)----- Despite this not being exported here, the documentation will--- be used by haddock, hence the user-facing blurb here, and not in primops.txt.pp:---- | This two-parameter class has instances for types @a@ and @b@ if---      the compiler can infer that they have the same representation. This class---      does not have regular instances; instead they are created on-the-fly during---      type-checking. Trying to manually declare an instance of @Coercible@---      is an error.------      Nevertheless one can pretend that the following three kinds of instances---      exist. First, as a trivial base-case:------      @instance a a@------      Furthermore, for every type constructor there is---      an instance that allows to coerce under the type constructor. For---      example, let @D@ be a prototypical type constructor (@data@ or---      @newtype@) with three type arguments, which have roles @nominal@,---      @representational@ resp. @phantom@. Then there is an instance of---      the form------      @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@------      Note that the @nominal@ type arguments are equal, the---      @representational@ type arguments can differ, but need to have a---      @Coercible@ instance themself, and the @phantom@ type arguments can be---      changed arbitrarily.------      The third kind of instance exists for every @newtype NT = MkNT T@ and---      comes in two variants, namely------      @instance Coercible a T => Coercible a NT@------      @instance Coercible T b => Coercible NT b@------      This instance is only usable if the constructor @MkNT@ is in scope.------      If, as a library author of a type constructor like @Set a@, you---      want to prevent a user of your module to write---      @coerce :: Set T -> Set NT@,---      you need to set the role of @Set@\'s type parameter to @nominal@,---      by writing------      @type role Set nominal@------      For more details about this feature, please refer to---      <http://www.cis.upenn.edu/~eir/papers/2014/coercible/coercible.pdf Safe Coercions>---      by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.------      /Since: 4.7.0.0/-data Coercible a b = MkCoercible ((~#) a b)---- | Alias for tagToEnum#. Returns True of its parameter is 1# and False---   if it is 0#.--{-# INLINE isTrue# #-}-isTrue# :: Int# -> Bool   -- See Note [Optimizing isTrue#]-isTrue# x = tagToEnum# x---- Note [Optimizing isTrue#]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ Current definition of isTrue# is a temporary workaround. We would like to--- have functions isTrue# and isFalse# defined like this:------     isTrue# :: Int# -> Bool---     isTrue# 1# = True---     isTrue# _  = False------     isFalse# :: Int# -> Bool---     isFalse# 0# = True---     isFalse# _  = False------ These functions would allow us to safely check if a tag can represent True--- or False. Using isTrue# and isFalse# as defined above will not introduce--- additional case into the code. When we scrutinize return value of isTrue#--- or isFalse#, either explicitly in a case expression or implicitly in a guard,--- the result will always be a single case expression (given that optimizations--- are turned on). This results from case-of-case transformation. Consider this--- code (this is both valid Haskell and Core):------ case isTrue# (a ># b) of---     True  -> e1---     False -> e2------ Inlining isTrue# gives:------ case (case (a ># b) of { 1# -> True; _ -> False } ) of---     True  -> e1---     False -> e2------ Case-of-case transforms that to:------ case (a ># b) of---   1# -> case True of---           True  -> e1---           False -> e2---   _  -> case False of---           True  -> e1---           False -> e2------ Which is then simplified by case-of-known-constructor:------ case (a ># b) of---   1# -> e1---   _  -> e2------ While we get good Core here, the code generator will generate very bad Cmm--- if e1 or e2 do allocation. It will push heap checks into case alternatives--- which results in about 2.5% increase in code size. Until this is improved we--- just make isTrue# an alias to tagToEnum#. This is a temporary solution (if--- you're reading this in 2023 then things went wrong). See #8326.------- | SPEC is used by GHC in the @SpecConstr@ pass in order to inform--- the compiler when to be particularly aggressive. In particular, it--- tells GHC to specialize regardless of size or the number of--- specializations. However, not all loops fall into this category.------ Libraries can specify this by using 'SPEC' data type to inform which--- loops should be aggressively specialized.-data SPEC = SPEC | SPEC2+{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples,+             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 &#x1F49C; hs"@, are translated into+-- Lists of characters, @[\'I\', \' \', \'&#x1F49C;\', \' \', \'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+--      <http://research.microsoft.com/en-us/um/people/simonpj/papers/ext-f/coercible.pdf Safe Coercions>+--      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 #)
Setup.hs view
@@ -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+
+ cbits/atomic.c view
@@ -0,0 +1,415 @@+#if !defined(arm_HOST_ARCH)+#include "Rts.h"++// Fallbacks for atomic primops on byte arrays. The builtins used+// below are supported on both GCC and LLVM.+//+// Ideally these function would take StgWord8, StgWord16, etc but+// older GCC versions incorrectly assume that the register that the+// argument is passed in has been zero extended, which is incorrect+// according to the ABI and is not what GHC does when it generates+// calls to these functions.++// FetchAddByteArrayOp_Int++extern StgWord hs_atomic_add8(StgWord x, StgWord val);+StgWord+hs_atomic_add8(StgWord x, StgWord val)+{+  return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);+}++extern StgWord hs_atomic_add16(StgWord x, StgWord val);+StgWord+hs_atomic_add16(StgWord x, StgWord val)+{+  return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);+}++extern StgWord hs_atomic_add32(StgWord x, StgWord val);+StgWord+hs_atomic_add32(StgWord x, StgWord val)+{+  return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);+}++extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_add64(StgWord x, StgWord64 val)+{+  return __sync_fetch_and_add((volatile StgWord64 *) x, val);+}++// FetchSubByteArrayOp_Int++extern StgWord hs_atomic_sub8(StgWord x, StgWord val);+StgWord+hs_atomic_sub8(StgWord x, StgWord val)+{+  return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);+}++extern StgWord hs_atomic_sub16(StgWord x, StgWord val);+StgWord+hs_atomic_sub16(StgWord x, StgWord val)+{+  return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);+}++extern StgWord hs_atomic_sub32(StgWord x, StgWord val);+StgWord+hs_atomic_sub32(StgWord x, StgWord val)+{+  return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);+}++extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_sub64(StgWord x, StgWord64 val)+{+  return __sync_fetch_and_sub((volatile StgWord64 *) x, val);+}++// FetchAndByteArrayOp_Int++extern StgWord hs_atomic_and8(StgWord x, StgWord val);+StgWord+hs_atomic_and8(StgWord x, StgWord val)+{+  return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);+}++extern StgWord hs_atomic_and16(StgWord x, StgWord val);+StgWord+hs_atomic_and16(StgWord x, StgWord val)+{+  return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);+}++extern StgWord hs_atomic_and32(StgWord x, StgWord val);+StgWord+hs_atomic_and32(StgWord x, StgWord val)+{+  return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);+}++extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_and64(StgWord x, StgWord64 val)+{+  return __sync_fetch_and_and((volatile StgWord64 *) x, val);+}++// FetchNandByteArrayOp_Int++// 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);                                   \+    while (!__sync_bool_compare_and_swap(x, tmp, ~(tmp & (val)))) { \+      tmp = *(x);                                                   \+    }                                                               \+    return tmp;                                                     \+  }++// 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(StgWord x, StgWord val)+{+#if USE_SYNC_FETCH_AND_NAND+  return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);+#else+  CAS_NAND((volatile StgWord8 *) x, (StgWord8) val)+#endif+}++extern StgWord hs_atomic_nand16(StgWord x, StgWord val);+StgWord+hs_atomic_nand16(StgWord x, StgWord val)+{+#if USE_SYNC_FETCH_AND_NAND+  return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);+#else+  CAS_NAND((volatile StgWord16 *) x, (StgWord16) val);+#endif+}++extern StgWord hs_atomic_nand32(StgWord x, StgWord val);+StgWord+hs_atomic_nand32(StgWord x, StgWord val)+{+#if USE_SYNC_FETCH_AND_NAND+  return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);+#else+  CAS_NAND((volatile StgWord32 *) x, (StgWord32) val);+#endif+}++extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_nand64(StgWord x, StgWord64 val)+{+#if USE_SYNC_FETCH_AND_NAND+  return __sync_fetch_and_nand((volatile StgWord64 *) x, val);+#else+  CAS_NAND((volatile StgWord64 *) x, val);+#endif+}++#pragma GCC diagnostic pop++// FetchOrByteArrayOp_Int++extern StgWord hs_atomic_or8(StgWord x, StgWord val);+StgWord+hs_atomic_or8(StgWord x, StgWord val)+{+  return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);+}++extern StgWord hs_atomic_or16(StgWord x, StgWord val);+StgWord+hs_atomic_or16(StgWord x, StgWord val)+{+  return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);+}++extern StgWord hs_atomic_or32(StgWord x, StgWord val);+StgWord+hs_atomic_or32(StgWord x, StgWord val)+{+  return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);+}++extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_or64(StgWord x, StgWord64 val)+{+  return __sync_fetch_and_or((volatile StgWord64 *) x, val);+}++// FetchXorByteArrayOp_Int++extern StgWord hs_atomic_xor8(StgWord x, StgWord val);+StgWord+hs_atomic_xor8(StgWord x, StgWord val)+{+  return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);+}++extern StgWord hs_atomic_xor16(StgWord x, StgWord val);+StgWord+hs_atomic_xor16(StgWord x, StgWord val)+{+  return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);+}++extern StgWord hs_atomic_xor32(StgWord x, StgWord val);+StgWord+hs_atomic_xor32(StgWord x, StgWord val)+{+  return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);+}++extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val);+StgWord64+hs_atomic_xor64(StgWord x, StgWord64 val)+{+  return __sync_fetch_and_xor((volatile StgWord64 *) x, val);+}++// CasByteArrayOp_Int++extern StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new);+StgWord+hs_cmpxchg8(StgWord x, StgWord old, StgWord 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(StgWord x, StgWord old, StgWord new);+StgWord+hs_cmpxchg16(StgWord x, StgWord old, StgWord 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(StgWord x, StgWord old, StgWord new);+StgWord+hs_cmpxchg32(StgWord x, StgWord old, StgWord new)+{+  StgWord32 expected = (StgWord32) old;+  __atomic_compare_exchange_n((StgWord32 *) x, &expected, (StgWord32) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);+  return expected;+}++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_xchg8(StgWord x, StgWord val)+{+  return (StgWord) __atomic_exchange_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);+}++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(StgWord x);+StgWord+hs_atomicread8(StgWord x)+{+  return __atomic_load_n((StgWord8 *) x, __ATOMIC_SEQ_CST);+}++extern StgWord hs_atomicread16(StgWord x);+StgWord+hs_atomicread16(StgWord x)+{+  return __atomic_load_n((StgWord16 *) x, __ATOMIC_SEQ_CST);+}++extern StgWord hs_atomicread32(StgWord x);+StgWord+hs_atomicread32(StgWord x)+{+  return __atomic_load_n((StgWord32 *) x, __ATOMIC_SEQ_CST);+}++extern StgWord64 hs_atomicread64(StgWord x);+StgWord64+hs_atomicread64(StgWord 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(StgWord x, StgWord val);+void+hs_atomicwrite8(StgWord x, StgWord val)+{+  __atomic_store_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);+}++extern void hs_atomicwrite16(StgWord x, StgWord val);+void+hs_atomicwrite16(StgWord x, StgWord val)+{+  __atomic_store_n((StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);+}++extern void hs_atomicwrite32(StgWord x, StgWord val);+void+hs_atomicwrite32(StgWord x, StgWord val)+{+  __atomic_store_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);+}++extern void hs_atomicwrite64(StgWord x, StgWord64 val);+void+hs_atomicwrite64(StgWord x, StgWord64 val)+{+  __atomic_store_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);+}++#endif
+ cbits/bitrev.c view
@@ -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;+}
+ cbits/clz.c view
@@ -0,0 +1,41 @@+#include "MachDeps.h"+#include "Rts.h"+#include <stdint.h>++// Fall-back implementations for count-leading-zeros primop+//+// __builtin_clz*() is supported by GCC and Clang++#if SIZEOF_UNSIGNED_INT == 4+StgWord+hs_clz8(StgWord x)+{+  return (uint8_t)x ? __builtin_clz((uint8_t)x)-24 : 8;+}++StgWord+hs_clz16(StgWord x)+{+  return (uint16_t)x ? __builtin_clz((uint16_t)x)-16 : 16;+}++StgWord+hs_clz32(StgWord x)+{+  return (uint32_t)x ? __builtin_clz((uint32_t)x) : 32;+}+#else+# error no suitable __builtin_clz() found+#endif++StgWord+hs_clz64(StgWord64 x)+{+#if SIZEOF_UNSIGNED_LONG == 8+  return x ? __builtin_clzl(x) : 64;+#elif SIZEOF_UNSIGNED_LONG_LONG == 8+  return x ? __builtin_clzll(x) : 64;+#else+# error no suitable __builtin_clz() found+#endif+}
+ cbits/ctz.c view
@@ -0,0 +1,57 @@+#include "MachDeps.h"+#include "Rts.h"+#include <stdint.h>++// Fall-back implementations for count-trailing-zeros primop+//+// __builtin_ctz*() is supported by GCC and Clang++#if SIZEOF_UNSIGNED_INT == 4+StgWord+hs_ctz8(StgWord x)+{+  return (uint8_t)x ? __builtin_ctz(x) : 8;+}++StgWord+hs_ctz16(StgWord x)+{+  return (uint16_t)x ? __builtin_ctz(x) : 16;+}++StgWord+hs_ctz32(StgWord x)+{+  return (uint32_t)x ? __builtin_ctz(x) : 32;+}+#else+# error no suitable __builtin_ctz() found+#endif++StgWord+hs_ctz64(StgWord64 x)+{+#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 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.+  */++  if (!x) return 64;++  return ((uint32_t)x ? __builtin_ctz((uint32_t)x)+                      : (__builtin_ctz(x >> 32) + 32));++#elif SIZEOF_UNSIGNED_LONG == 8+  return x ? __builtin_ctzl(x) : 64;+#elif SIZEOF_UNSIGNED_LONG_LONG == 8+  return x ? __builtin_ctzll(x) : 64;+#else+# error no suitable __builtin_ctz() found+#endif+}
cbits/longlong.c view
@@ -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 */
+ cbits/mulIntMayOflo.c view
@@ -0,0 +1,3 @@+#include "Rts.h"++W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); }
+ cbits/pdep.c view
@@ -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);+}
+ cbits/pext.c view
@@ -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);+}
cbits/popcnt.c view
@@ -1,4 +1,5 @@ #include "Rts.h"+#include "MachDeps.h"  static const unsigned char popcount_tab[] = {@@ -51,7 +52,7 @@       popcount_tab[(unsigned char)(x >> 56)]; } -#ifdef i386_HOST_ARCH+#if WORD_SIZE_IN_BITS == 32  extern StgWord hs_popcnt(StgWord x); StgWord@@ -63,7 +64,7 @@       popcount_tab[(unsigned char)(x >> 24)]; } -#else+#elif WORD_SIZE_IN_BITS == 64  extern StgWord hs_popcnt(StgWord x); StgWord@@ -78,5 +79,9 @@       popcount_tab[(unsigned char)(x >> 48)] +       popcount_tab[(unsigned char)(x >> 56)]; }++#else++#error Unknown machine word size  #endif
+ changelog.md view
@@ -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#<N>`+  - Unboxed sum tycons are now `Sum#<N>`+  - Constraint tuple classes are now `CTuple<N>`+  - Unit tycons are now `Unit#`, `CUnit`.+  - Solo tycons are now `Solo#`, `CSolo`.+  - `Tuple<N>` 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}<N>Array# :: ByteArray# -> Int# -> {Int,Word}<N>#`+   - `indexWord8ArrayAs{Int,Word}<N># :: ByteArray# -> Int# -> {Int,Word}<N>#`+   - `read{Int,Word}<N>Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}<N># #)`+   - `write{Int,Word}<N>Array# :: MutableByteArray# s -> Int# -> {Int,Word}<N># -> State# s -> State# s`+   - `readWord8ArrayAs{Int,Word}<N># :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}<N># #)`+   - `writeWord8ArrayAs{Int,Word}<N># :: MutableByteArray# s -> Int# -> {Int,Word}<N># -> 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}<N>#` -> `extend<N>To{Int,Word}#`+   - `narrow{Int,Word}<N>#` -> `intTo{Int,Word}<N>#`++- 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
ghc-prim.cabal view
@@ -1,29 +1,34 @@+cabal-version:  2.2 name:           ghc-prim-version:        0.3.1.0--- GHC 7.6.1 released with 0.3.0.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/packages/ghc-prim.git+    location: https://gitlab.haskell.org/ghc/ghc.git+    subdir:   libraries/ghc-prim -source-repository this-    type:     git-    location: http://git.haskell.org/packages/ghc-prim.git-    tag:      ghc-prim-0.3.1.0-release+custom-setup+    setup-depends: base >= 4 && < 5, process, filepath, directory, Cabal >= 1.23 && < 3.9 -flag include-ghc-prim-    Description: Include GHC.Prim in exposed-modules-    default: False+flag need-atomic+  default: False  Library     default-language: Haskell2010@@ -46,22 +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/bswap.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 name 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: -package-name ghc-prim+    ghc-options: -this-unit-id ghc-prim