diff --git a/GHC/CString.hs b/GHC/CString.hs --- a/GHC/CString.hs +++ b/GHC/CString.hs @@ -5,7 +5,7 @@ -- 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) -- @@ -135,9 +135,9 @@ All of this goes for unpackCStringUtf8# too. -} -{- Note [Inlining of unpackFoldrCString] +{- +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) @@ -154,9 +154,8 @@ This is especially important for elem which then results in an allocation free loop. - Note [unpackCString# iterating over addr] +Note [unpackCString# iterating over addr] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - When unpacking unpackCString# and friends repeatedly return a cons cell containing: * The current character we just unpacked. @@ -175,7 +174,6 @@ This has the additional advantage the we can guarantee that only the increment will happen in the loop. - -} unpackCString# :: Addr# -> [Char] @@ -227,7 +225,6 @@ -- See Note [unpackCString# iterating over addr] !ch = indexCharOffAddr# addr 0# - unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char] {-# NOINLINE unpackAppendCStringUtf8# #-} -- See the NOINLINE note on unpackCString# @@ -290,8 +287,12 @@ ------------------------------ ---- UTF8 decoding utilities +--- 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 diff --git a/GHC/Classes.hs b/GHC/Classes.hs --- a/GHC/Classes.hs +++ b/GHC/Classes.hs @@ -1,908 +1,1608 @@ -{-# LANGUAGE CPP, Trustworthy #-} -{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns, - KindSignatures, DataKinds, ConstraintKinds, - MultiParamTypeClasses, FunctionalDependencies #-} -{-# LANGUAGE AllowAmbiguousTypes #-} - -- ip :: IP x a => a is strictly speaking ambiguous, but IP is magic -{-# LANGUAGE UndecidableSuperClasses #-} - -- Because of the type-variable superclasses for tuples - -{-# OPTIONS_GHC -Wno-unused-imports #-} --- -Wno-unused-imports needed for the GHC.Tuple import below. Sigh. - -{-# OPTIONS_GHC -Wno-unused-top-binds #-} --- -Wno-unused-top-binds is there (I hope) to stop Haddock complaining --- about the constraint tuples being defined but not used - -{-# OPTIONS_HADDOCK not-home #-} ------------------------------------------------------------------------------ --- | --- Module : GHC.Classes --- Copyright : (c) The University of Glasgow, 1992-2002 --- License : see libraries/base/LICENSE --- --- Maintainer : cvs-ghc@haskell.org --- Stability : internal --- Portability : non-portable (GHC extensions) --- --- Basic classes. --- ------------------------------------------------------------------------------ - -module GHC.Classes( - -- * Implicit paramaters - IP(..), - - -- * Equality and ordering - 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 - (&&), (||), not, - - -- * Integer arithmetic - divInt#, modInt# - ) 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 - -#include "MachDeps.h" - -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)@ --- --- 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 (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) - -#if WORD_SIZE_IN_BITS < 64 -instance Eq TyCon where - (==) (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) - = isTrue# (hi1 `eqWord64#` hi2) && isTrue# (lo1 `eqWord64#` lo2) -instance Ord TyCon where - compare (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) - | isTrue# (hi1 `gtWord64#` hi2) = GT - | isTrue# (hi1 `ltWord64#` hi2) = LT - | isTrue# (lo1 `gtWord64#` lo2) = GT - | isTrue# (lo1 `ltWord64#` lo2) = LT - | True = EQ -#else -instance Eq TyCon where - (==) (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) - = isTrue# (hi1 `eqWord#` hi2) && isTrue# (lo1 `eqWord#` lo2) -instance Ord TyCon where - compare (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) - | isTrue# (hi1 `gtWord#` hi2) = GT - | isTrue# (hi1 `ltWord#` hi2) = LT - | isTrue# (lo1 `gtWord#` lo2) = GT - | isTrue# (lo1 `ltWord#` lo2) = LT - | True = EQ -#endif - - --- | The 'Ord' class is used for totally ordered datatypes. --- --- Instances of 'Ord' can be derived for any user-defined 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 '(==)'. --- --- 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 (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) - --- | Note that due to the presence of @NaN@, `Float`'s 'Ord' instance does not --- satisfy reflexivity. --- --- >>> 0/0 <= (0/0 :: Float) --- False --- --- Also note that, due to the same, `Ord`'s operator interactions are not --- respected by `Float`'s instance: --- --- >>> (0/0 :: Float) > 1 --- False --- >>> compare (0/0 :: Float) 1 --- GT -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) - --- | Note that due to the presence of @NaN@, `Double`'s 'Ord' instance does not --- satisfy reflexivity. --- --- >>> 0/0 <= (0/0 :: Double) --- False --- --- Also note that, due to the same, `Ord`'s operator interactions are not --- respected by `Double`'s instance: --- --- >>> (0/0 :: Double) > 1 --- False --- >>> compare (0/0 :: Double) 1 --- GT -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) - -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) - -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. -{-# NOINLINE [0] divInt# #-} -{-# NOINLINE [0] modInt# #-} -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# - - -{- ************************************************************* -* * -* Constraint tuples * -* * -************************************************************* -} - -class () -class (c1, c2) => (c1, c2) -class (c1, c2, c3) => (c1, c2, c3) -class (c1, c2, c3, c4) => (c1, c2, c3, c4) -class (c1, c2, c3, c4, c5) => (c1, c2, c3, c4, c5) -class (c1, c2, c3, c4, c5, c6) => (c1, c2, c3, c4, c5, c6) -class (c1, c2, c3, c4, c5, c6, c7) => (c1, c2, c3, c4, c5, c6, c7) -class (c1, c2, c3, c4, c5, c6, c7, c8) => (c1, c2, c3, c4, c5, c6, c7, c8) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17,c18) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60, c61) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60, c61) -class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60, c61, c62) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, - c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, - c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, - c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, - c59, c60, c61, c62) -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) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, 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) - => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, 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) +{-# LANGUAGE Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns, + KindSignatures, DataKinds, ConstraintKinds, + MultiParamTypeClasses, FunctionalDependencies #-} +{-# LANGUAGE UnboxedTuples #-} +{-# LANGUAGE AllowAmbiguousTypes #-} + -- ip :: IP x a => a is strictly speaking ambiguous, but IP is magic +{-# LANGUAGE UndecidableSuperClasses #-} + -- Because of the type-variable superclasses for tuples + +{-# OPTIONS_GHC -Wno-unused-imports #-} +-- -Wno-unused-imports needed for the GHC.Tuple import below. Sigh. + +{-# OPTIONS_GHC -Wno-unused-top-binds #-} +-- -Wno-unused-top-binds is there (I hope) to stop Haddock complaining +-- about the constraint tuples being defined but not used + +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE UndecidableSuperClasses #-} +{-# LANGUAGE ConstraintKinds #-} + +{-# OPTIONS_HADDOCK not-home #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Classes +-- Copyright : (c) The University of Glasgow, 1992-2002 +-- License : see libraries/base/LICENSE +-- +-- Maintainer : ghc-devs@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC extensions) +-- +-- Basic classes. +-- Do not import this module directly. It is an GHC internal only +-- module. Some of its contents are instead available from @Prelude@ +-- and @GHC.Int@. +-- +----------------------------------------------------------------------------- + +module GHC.Classes( + -- * Implicit parameters + IP(..), + + -- * Equality and ordering + -- | Do not import these classes from this module. Import them + -- from @Prelude@ instead. + Eq(..), + Ord(..), + -- ** Monomorphic equality operators + -- $matching_overloaded_methods_in_rules + eqInt, neInt, + eqWord, neWord, + eqChar, neChar, + eqFloat, eqDouble, + -- ** Monomorphic comparison operators + gtInt, geInt, leInt, ltInt, compareInt, compareInt#, + gtWord, geWord, leWord, ltWord, compareWord, compareWord#, + + -- * Functions over Bool + -- | Do not import these functions from this module. Import them + -- from @Prelude@ instead. + (&&), (||), not, + + -- * Integer arithmetic + divInt#, divInt8#, divInt16#, divInt32#, + modInt#, modInt8#, modInt16#, modInt32#, + divModInt#, divModInt8#, divModInt16#, divModInt32#, + + -- * Constraint tuples + CUnit, + CSolo, + CTuple0, + CTuple1, + CTuple2, + CTuple3, + CTuple4, + CTuple5, + CTuple6, + CTuple7, + CTuple8, + CTuple9, + CTuple10, + CTuple11, + CTuple12, + CTuple13, + CTuple14, + CTuple15, + CTuple16, + CTuple17, + CTuple18, + CTuple19, + CTuple20, + CTuple21, + CTuple22, + CTuple23, + CTuple24, + CTuple25, + CTuple26, + CTuple27, + CTuple28, + CTuple29, + CTuple30, + CTuple31, + CTuple32, + CTuple33, + CTuple34, + CTuple35, + CTuple36, + CTuple37, + CTuple38, + CTuple39, + CTuple40, + CTuple41, + CTuple42, + CTuple43, + CTuple44, + CTuple45, + CTuple46, + CTuple47, + CTuple48, + CTuple49, + CTuple50, + CTuple51, + CTuple52, + CTuple53, + CTuple54, + CTuple55, + CTuple56, + CTuple57, + CTuple58, + CTuple59, + CTuple60, + CTuple61, + CTuple62, + CTuple63, + CTuple64, + ) where + +-- GHC.Magic is used in some derived instances +import GHC.Magic () +import GHC.Prim +import GHC.Tuple +import GHC.CString (unpackCString#) +import GHC.Types + +infix 4 ==, /=, <, <=, >=, > +infixr 3 && +infixr 2 || + +default () -- Double isn't available yet + +-- | The syntax @?x :: a@ is desugared into @IP "x" a@ +-- IP is declared very early, so that libraries can take +-- advantage of the implicit-call-stack feature +class IP (x :: Symbol) a | x -> a where + ip :: a + +{- $matching_overloaded_methods_in_rules + +Matching on class methods (e.g. @(==)@) in rewrite rules tends to be a bit +fragile. For instance, consider this motivating example from the @bytestring@ +library, + +@ +break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) +breakByte :: Word8 -> ByteString -> (ByteString, ByteString) +\{\-\# RULES "break -> breakByte" forall a. break (== x) = breakByte x \#\-\} +@ + +Here we have two functions, with @breakByte@ providing an optimized +implementation of @break@ where the predicate is merely testing for equality +with a known @Word8@. As written, however, this rule will be quite fragile as +the @(==)@ class operation rule may rewrite the predicate before our @break@ +rule has a chance to fire. + +For this reason, most of the primitive types in @base@ have 'Eq' and 'Ord' +instances defined in terms of helper functions with inlinings delayed to phase +1. For instance, @Word8@\'s @Eq@ instance looks like, + +@ +instance Eq Word8 where + (==) = eqWord8 + (/=) = neWord8 + +eqWord8, neWord8 :: Word8 -> Word8 -> Bool +eqWord8 (W8# x) (W8# y) = ... +neWord8 (W8# x) (W8# y) = ... +\{\-\# INLINE [1] eqWord8 \#\-\} +\{\-\# INLINE [1] neWord8 \#\-\} +@ + +This allows us to save our @break@ rule above by rewriting it to instead match +against @eqWord8@, + +@ +\{\-\# RULES "break -> breakByte" forall a. break (`eqWord8` x) = breakByte x \#\-\} +@ + +Currently this is only done for @('==')@, @('/=')@, @('<')@, @('<=')@, @('>')@, +and @('>=')@ for the types in "GHC.Word" and "GHC.Int". +-} + +-- | The 'Eq' class defines equality ('==') and inequality ('/='). +-- All the basic datatypes exported by the "Prelude" are instances of 'Eq', +-- and 'Eq' may be derived for any datatype whose constituents are also +-- instances of 'Eq'. +-- +-- The Haskell Report defines no laws for 'Eq'. However, instances are +-- encouraged to follow these properties: +-- +-- [__Reflexivity__]: @x == x@ = 'True' +-- [__Symmetry__]: @x == y@ = @y == x@ +-- [__Transitivity__]: if @x == y && y == z@ = 'True', then @x == z@ = 'True' +-- [__Extensionality__]: if @x == y@ = 'True' and @f@ is a function +-- whose return type is an instance of 'Eq', then @f x == f y@ = 'True' +-- [__Negation__]: @x /= y@ = @not (x == y)@ +class Eq a where + (==), (/=) :: a -> a -> Bool + + {-# INLINE (/=) #-} + {-# INLINE (==) #-} + x /= y = not (x == y) + x == y = not (x /= y) + {-# MINIMAL (==) | (/=) #-} + +deriving instance Eq () +deriving instance Eq a => Eq (Solo a) +deriving instance (Eq a, Eq b) => Eq (a, b) +deriving instance (Eq a, Eq b, Eq c) => Eq (a, b, c) +deriving instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) + => Eq (a, b, c, d, e, f) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) + => Eq (a, b, c, d, e, f, g) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h) + => Eq (a, b, c, d, e, f, g, h) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i) + => Eq (a, b, c, d, e, f, g, h, i) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j) + => Eq (a, b, c, d, e, f, g, h, i, j) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k) + => Eq (a, b, c, d, e, f, g, h, i, j, k) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) + +instance (Eq a) => Eq [a] where + {-# SPECIALISE instance Eq [[Char]] #-} + {-# SPECIALISE instance Eq [Char] #-} + {-# SPECIALISE instance Eq [Int] #-} + [] == [] = True + (x:xs) == (y:ys) = x == y && xs == ys + _xs == _ys = False + +deriving instance Eq Module + +instance Eq TrName where + TrNameS a == TrNameS b = isTrue# (a `eqAddr#` b) + a == b = toString a == toString b + where + toString (TrNameS s) = unpackCString# s + toString (TrNameD s) = s + +deriving instance Eq Bool +deriving instance Eq Ordering + +instance Eq Word where + (==) = eqWord + (/=) = neWord + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqWord #-} +{-# INLINE [1] neWord #-} +eqWord, neWord :: Word -> Word -> Bool +(W# x) `eqWord` (W# y) = isTrue# (x `eqWord#` y) +(W# x) `neWord` (W# y) = isTrue# (x `neWord#` y) + +-- See GHC.Classes#matching_overloaded_methods_in_rules +instance Eq Char where + (==) = eqChar + (/=) = neChar + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqChar #-} +{-# INLINE [1] neChar #-} +eqChar, neChar :: Char -> Char -> Bool +(C# x) `eqChar` (C# y) = isTrue# (x `eqChar#` y) +(C# x) `neChar` (C# y) = isTrue# (x `neChar#` y) + +-- | Note that due to the presence of @NaN@, `Float`'s 'Eq' instance does not +-- satisfy reflexivity. +-- +-- >>> 0/0 == (0/0 :: Float) +-- False +-- +-- Also note that `Float`'s 'Eq' instance does not satisfy extensionality: +-- +-- >>> 0 == (-0 :: Float) +-- True +-- >>> recip 0 == recip (-0 :: Float) +-- False +instance Eq Float where + (==) = eqFloat + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqFloat #-} +eqFloat :: Float -> Float -> Bool +(F# x) `eqFloat` (F# y) = isTrue# (x `eqFloat#` y) + +-- | Note that due to the presence of @NaN@, `Double`'s 'Eq' instance does not +-- satisfy reflexivity. +-- +-- >>> 0/0 == (0/0 :: Double) +-- False +-- +-- Also note that `Double`'s 'Eq' instance does not satisfy substitutivity: +-- +-- >>> 0 == (-0 :: Double) +-- True +-- >>> recip 0 == recip (-0 :: Double) +-- False +instance Eq Double where + (==) = eqDouble + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqDouble #-} +eqDouble :: Double -> Double -> Bool +(D# x) `eqDouble` (D# y) = isTrue# (x ==## y) + +instance Eq Int where + (==) = eqInt + (/=) = neInt + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqInt #-} +{-# INLINE [1] neInt #-} +eqInt, neInt :: Int -> Int -> Bool +(I# x) `eqInt` (I# y) = isTrue# (x ==# y) +(I# x) `neInt` (I# y) = isTrue# (x /=# y) + +instance Eq TyCon where + (==) (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) + = isTrue# (hi1 `eqWord64#` hi2) && isTrue# (lo1 `eqWord64#` lo2) +instance Ord TyCon where + compare (TyCon hi1 lo1 _ _ _ _) (TyCon hi2 lo2 _ _ _ _) + | isTrue# (hi1 `gtWord64#` hi2) = GT + | isTrue# (hi1 `ltWord64#` hi2) = LT + | isTrue# (lo1 `gtWord64#` lo2) = GT + | isTrue# (lo1 `ltWord64#` lo2) = LT + | True = EQ + + +-- | The 'Ord' class is used for totally ordered datatypes. +-- +-- Instances of 'Ord' can be derived for any user-defined datatype whose +-- constituent types are in 'Ord'. The declared order of the constructors in +-- the data declaration determines the ordering in derived 'Ord' instances. The +-- 'Ordering' datatype allows a single comparison to determine the precise +-- ordering of two objects. +-- +-- 'Ord', as defined by the Haskell report, implements a total order and has the +-- following properties: +-- +-- [__Comparability__]: @x <= y || y <= x@ = 'True' +-- [__Transitivity__]: if @x <= y && y <= z@ = 'True', then @x <= z@ = 'True' +-- [__Reflexivity__]: @x <= x@ = 'True' +-- [__Antisymmetry__]: if @x <= y && y <= x@ = 'True', then @x == y@ = 'True' +-- +-- The following operator interactions are expected to hold: +-- +-- 1. @x >= y@ = @y <= x@ +-- 2. @x < y@ = @x <= y && x /= y@ +-- 3. @x > y@ = @y < x@ +-- 4. @x < y@ = @compare x y == LT@ +-- 5. @x > y@ = @compare x y == GT@ +-- 6. @x == y@ = @compare x y == EQ@ +-- 7. @min x y == if x <= y then x else y@ = 'True' +-- 8. @max x y == if x >= y then x else y@ = 'True' +-- +-- Note that (7.) and (8.) do /not/ require 'min' and 'max' to return either of +-- their arguments. The result is merely required to /equal/ one of the +-- arguments in terms of '(==)'. Users who expect a stronger guarantee are advised +-- to write their own min and/or max functions. +-- +-- The nuance of the above distinction is not always fully internalized by +-- developers, and in the past (tracing back to the Haskell 1.4 Report) the +-- specification for 'Ord' asserted the stronger property that @(min x y, max x +-- y) = (x, y)@ or @(y, x)@, or in other words, that 'min' and 'max' /will/ +-- return one of their arguments, using argument order as the tie-breaker if +-- the arguments are equal by comparison. A few list and +-- 'Data.Foldable.Foldable' functions have behavior that is best understood +-- with this assumption in mind: all variations of @minimumBy@ and @maximumBy@ +-- (which can't use 'min' and 'max' in their implementations) are written such +-- that @minimumBy 'compare'@ and @maximumBy 'compare'@ are respectively +-- equivalent to @minimum@ and @maximum@ (which do use 'min' and 'max') only if +-- 'min' and 'max' adhere to this tie-breaking convention. Otherwise, if there +-- are multiple least or largest elements in a container, @minimum@ and +-- @maximum@ may not return the /same/ one that @minimumBy 'compare'@ and +-- @maximumBy 'compare'@ do (though they should return something that is +-- /equal/). (This is relevant for types with non-extensional equality, like +-- 'Data.Semigroup.Arg', but also in cases where the precise reference held +-- matters for memory-management reasons.) Unless there is a reason to deviate, +-- it is less confusing for implementors of 'Ord' to respect this same +-- convention (as the default definitions of 'min' and 'max' do). +-- +-- Minimal complete definition: either 'compare' or '<='. +-- Using 'compare' can be more efficient for complex types. +-- +class (Eq a) => Ord a where + compare :: a -> a -> Ordering + (<), (<=), (>), (>=) :: a -> a -> Bool + max, min :: a -> a -> a + + compare x y = if x == y then EQ + -- NB: must be '<=' not '<' to validate the + -- above claim about the minimal things that + -- can be defined for an instance of Ord: + else if x <= y then LT + else GT + + x <= y = case compare x y of { GT -> False; _ -> True } + x >= y = y <= x + x > y = not (x <= y) + x < y = not (y <= x) + + + -- These two default methods use '<=' rather than 'compare' + -- because the latter is often more expensive + max x y = if x <= y then y else x + min x y = if x <= y then x else y + {-# MINIMAL compare | (<=) #-} + +deriving instance Ord () +deriving instance Ord a => Ord (Solo a) +deriving instance (Ord a, Ord b) => Ord (a, b) +deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c) +deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) + => Ord (a, b, c, d, e, f) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) + => Ord (a, b, c, d, e, f, g) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h) + => Ord (a, b, c, d, e, f, g, h) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i) + => Ord (a, b, c, d, e, f, g, h, i) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j) + => Ord (a, b, c, d, e, f, g, h, i, j) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k) + => Ord (a, b, c, d, e, f, g, h, i, j, k) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) + +instance (Ord a) => Ord [a] where + {-# SPECIALISE instance Ord [[Char]] #-} + {-# SPECIALISE instance Ord [Char] #-} + {-# SPECIALISE instance Ord [Int] #-} + compare [] [] = EQ + compare [] (_:_) = LT + compare (_:_) [] = GT + compare (x:xs) (y:ys) = case compare x y of + EQ -> compare xs ys + other -> other + +deriving instance Ord Bool +deriving instance Ord Ordering + +-- We don't use deriving for Ord Char, because for Ord the derived +-- instance defines only compare, which takes two primops. Then +-- '>' uses compare, and therefore takes two primops instead of one. +instance Ord Char where + (C# c1) > (C# c2) = isTrue# (c1 `gtChar#` c2) + (C# c1) >= (C# c2) = isTrue# (c1 `geChar#` c2) + (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2) + (C# c1) < (C# c2) = isTrue# (c1 `ltChar#` c2) + +-- | See @instance@ 'Ord' 'Double' for discussion of deviations from IEEE 754 standard. +instance Ord Float where + (F# x) `compare` (F# y) + = if isTrue# (x `ltFloat#` y) then LT + else if isTrue# (x `eqFloat#` y) then EQ + else GT + + (F# x) < (F# y) = isTrue# (x `ltFloat#` y) + (F# x) <= (F# y) = isTrue# (x `leFloat#` y) + (F# x) >= (F# y) = isTrue# (x `geFloat#` y) + (F# x) > (F# y) = isTrue# (x `gtFloat#` y) + +-- | IEEE 754 'Double'-precision type includes not only numbers, but also +-- positive and negative infinities and a special element called @NaN@ +-- (which can be quiet or signal). +-- +-- IEEE 754-2008, section 5.11 requires that if at least one of arguments of +-- '<=', '<', '>', '>=' is @NaN@ then the result of the comparison is 'False', +-- and @instance@ 'Ord' 'Double' complies with this requirement. This violates +-- the reflexivity: both @NaN@ '<=' @NaN@ and @NaN@ '>=' @NaN@ are 'False'. +-- +-- IEEE 754-2008, section 5.10 defines @totalOrder@ predicate. Unfortunately, +-- 'compare' on 'Double's violates the IEEE standard and does not define a total order. +-- More specifically, both 'compare' @NaN@ @x@ and 'compare' @x@ @NaN@ always return 'GT'. +-- +-- Thus, users must be extremely cautious when using @instance@ 'Ord' 'Double'. +-- For instance, one should avoid ordered containers with keys represented by 'Double', +-- because data loss and corruption may happen. An IEEE-compliant 'compare' is available +-- in @fp-ieee@ package as @TotallyOrdered@ newtype. +-- +-- Moving further, the behaviour of 'min' and 'max' with regards to @NaN@ is +-- also non-compliant. IEEE 754-2008, section 5.3.1 defines that quiet @NaN@ +-- should be treated as a missing data by @minNum@ and @maxNum@ functions, +-- for example, @minNum(NaN, 1) = minNum(1, NaN) = 1@. Some languages such as Java +-- deviate from the standard implementing @minNum(NaN, 1) = minNum(1, NaN) = NaN@. +-- However, 'min' / 'max' in @base@ are even worse: 'min' @NaN@ 1 is 1, but 'min' 1 @NaN@ +-- is @NaN@. +-- +-- IEEE 754-2008 compliant 'min' / 'max' can be found in @ieee754@ package under +-- @minNum@ / @maxNum@ names. Implementations compliant with +-- @minimumNumber@ / @maximumNumber@ from a newer +-- [IEEE 754-2019](https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/), +-- section 9.6 are available from @fp-ieee@ package. +-- +instance Ord Double where + (D# x) `compare` (D# y) + = if isTrue# (x <## y) then LT + else if isTrue# (x ==## y) then EQ + else GT + + (D# x) < (D# y) = isTrue# (x <## y) + (D# x) <= (D# y) = isTrue# (x <=## y) + (D# x) >= (D# y) = isTrue# (x >=## y) + (D# x) > (D# y) = isTrue# (x >## y) + +instance Ord Int where + compare = compareInt + (<) = ltInt + (<=) = leInt + (>=) = geInt + (>) = gtInt + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] gtInt #-} +{-# INLINE [1] geInt #-} +{-# INLINE [1] ltInt #-} +{-# INLINE [1] leInt #-} +gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool +(I# x) `gtInt` (I# y) = isTrue# (x ># y) +(I# x) `geInt` (I# y) = isTrue# (x >=# y) +(I# x) `ltInt` (I# y) = isTrue# (x <# y) +(I# x) `leInt` (I# y) = isTrue# (x <=# y) + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] compareInt #-} +compareInt :: Int -> Int -> Ordering +(I# x#) `compareInt` (I# y#) = compareInt# x# y# + +compareInt# :: Int# -> Int# -> Ordering +compareInt# x# y# + | isTrue# (x# <# y#) = LT + | isTrue# (x# ==# y#) = EQ + | True = GT + +instance Ord Word where + compare = compareWord + (<) = ltWord + (<=) = leWord + (>=) = geWord + (>) = gtWord + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] gtWord #-} +{-# INLINE [1] geWord #-} +{-# INLINE [1] ltWord #-} +{-# INLINE [1] leWord #-} +gtWord, geWord, ltWord, leWord :: Word -> Word -> Bool +(W# x) `gtWord` (W# y) = isTrue# (x `gtWord#` y) +(W# x) `geWord` (W# y) = isTrue# (x `geWord#` y) +(W# x) `ltWord` (W# y) = isTrue# (x `ltWord#` y) +(W# x) `leWord` (W# y) = isTrue# (x `leWord#` y) + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] compareWord #-} +compareWord :: Word -> Word -> Ordering +(W# x#) `compareWord` (W# y#) = compareWord# x# y# + +compareWord# :: Word# -> Word# -> Ordering +compareWord# x# y# + | isTrue# (x# `ltWord#` y#) = LT + | isTrue# (x# `eqWord#` y#) = EQ + | True = GT + +-- OK, so they're technically not part of a class...: + +-- Boolean functions + +-- | Boolean \"and\", lazy in the second argument +(&&) :: Bool -> Bool -> Bool +True && x = x +False && _ = False + +-- | Boolean \"or\", lazy in the second argument +(||) :: Bool -> Bool -> Bool +True || _ = True +False || x = x + +-- | Boolean \"not\" +not :: Bool -> Bool +not True = False +not False = True + + +------------------------------------------------------------------------ +-- These don't really belong here, but we don't have a better place to +-- put them + +-- These functions have built-in rules. +{-# INLINE [0] divInt# #-} +divInt# :: Int# -> Int# -> Int# +x# `divInt#` y# = ((x# +# bias#) `quotInt#` y#) -# hard# + where + -- See Note [divInt# implementation] + !yn# = y# <# 0# + !c0# = (x# <# 0#) `andI#` (notI# yn#) + !c1# = (x# ># 0#) `andI#` yn# + !bias# = c0# -# c1# + !hard# = c0# `orI#` c1# + +{-# INLINE [0] divInt8# #-} +divInt8# :: Int8# -> Int8# -> Int8# +x# `divInt8#` y# = ((x# `plusInt8#` bias#) `quotInt8#` y#) `subInt8#` hard# + where + zero# = intToInt8# 0# + x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y) + x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y) + notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x)) + -- See Note [divInt# implementation] + !yn# = intToInt8# (y# `ltInt8#` zero#) + !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#) + !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn# + !bias# = c0# `subInt8#` c1# + !hard# = c0# `orInt8#` c1# + +{-# INLINE [0] divInt16# #-} +divInt16# :: Int16# -> Int16# -> Int16# +x# `divInt16#` y# = ((x# `plusInt16#` bias#) `quotInt16#` y#) `subInt16#` hard# + where + zero# = intToInt16# 0# + x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y) + x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y) + notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x)) + -- See Note [divInt# implementation] + !yn# = intToInt16# (y# `ltInt16#` zero#) + !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#) + !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn# + !bias# = c0# `subInt16#` c1# + !hard# = c0# `orInt16#` c1# + +{-# INLINE [0] divInt32# #-} +divInt32# :: Int32# -> Int32# -> Int32# +x# `divInt32#` y# = ((x# `plusInt32#` bias#) `quotInt32#` y#) `subInt32#` hard# + where + zero# = intToInt32# 0# + x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y) + x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y) + notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x)) + -- See Note [divInt# implementation] + !yn# = intToInt32# (y# `ltInt32#` zero#) + !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#) + !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn# + !bias# = c0# `subInt32#` c1# + !hard# = c0# `orInt32#` c1# + +-- Note [divInt# implementation] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- divInt# (truncated toward zero) is implemented with quotInt# (truncated +-- toward negative infinity). They differ when inputs x and y have different signs: +-- - x `rem` y has the sign of x and (x `quot` y)*y + (x `rem` y) == x +-- - x `mod` y has the sign of y and (x `div` y)*y + (x `mod` y) == x +-- +-- So we bias the input and the result of quotInt as follows: +-- +-- if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1# +-- else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1# +-- else x# `quotInt#` y# +-- +-- However this leads to assembly code with lots of branches (#19636) while we +-- would like simpler code that we could inline (#18067). So we use some +-- branchless code instead as derived below: +-- +-- if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1# +-- else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1# +-- else x# `quotInt#` y# +-- +-- ===> { Give names to constants and always use them } +-- +-- ((x# +# bias#) `quotInt#` y#) -# hard# +-- where +-- (bias#,hard#) +-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) = (-1#, 1#) +-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) = ( 1#, 1#) +-- | otherwise = ( 0#, 0#) +-- +-- ===> { Compute bias# and hard# independently using Bool# (0#,1#) } +-- +-- ((x# +# bias#) `quotInt#` y#) -# hard# +-- where +-- c0# = (x# <# 0#) &&# (y# ># 0#) +-- c1# = (x# ># 0#) &&# (y# <# 0#) +-- bias# = c0# -# c1# -- both cases are mutually exclusive so we can subtract them +-- hard# = c0# ||# c1# -- (we could add them too here but OR is slightly better) +-- +-- ===> { Use yn# variable for "y# <# 0#" } +-- +-- ((x# +# bias#) `quotInt#` y#) -# hard# +-- where +-- -- y# ==# 0# throws an exception so we don't need to consider it +-- yn# = y# <# 0# +-- c0# = (x# <# 0#) &&# (notI# yn#) +-- c1# = (x# ># 0#) &&# yn# +-- bias# = c0# -# c1# +-- hard# = c0# ||# c1# +-- +-- +-- Note that we need to be careful NOT to overflow if we do any additional +-- arithmetic on the arguments... the following previous version of this code +-- had problems with overflow: +-- | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y# +-- | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y# + +{-# INLINE [0] modInt# #-} +modInt# :: Int# -> Int# -> Int# +x# `modInt#` y# = r# +# k# + where + -- See Note [modInt# implementation] + !yn# = y# <# 0# + !c0# = (x# <# 0#) `andI#` (notI# yn#) + !c1# = (x# ># 0#) `andI#` yn# + !s# = 0# -# ((c0# `orI#` c1#) `andI#` (r# /=# 0#)) + !k# = s# `andI#` y# + !r# = x# `remInt#` y# + +{-# INLINE [0] modInt8# #-} +modInt8# :: Int8# -> Int8# -> Int8# +x# `modInt8#` y# = r# `plusInt8#` k# + where + zero# = intToInt8# 0# + x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y) + x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y) + notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x)) + -- See Note [modInt# implementation] + !yn# = intToInt8# (y# `ltInt8#` zero#) + !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#) + !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn# + !s# = zero# `subInt8#` ((c0# `orInt8#` c1#) `andInt8#` (intToInt8# (r# `neInt8#` zero#))) + !k# = s# `andInt8#` y# + !r# = x# `remInt8#` y# + +{-# INLINE [0] modInt16# #-} +modInt16# :: Int16# -> Int16# -> Int16# +x# `modInt16#` y# = r# `plusInt16#` k# + where + zero# = intToInt16# 0# + x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y) + x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y) + notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x)) + -- See Note [modInt# implementation] + !yn# = intToInt16# (y# `ltInt16#` zero#) + !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#) + !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn# + !s# = zero# `subInt16#` ((c0# `orInt16#` c1#) `andInt16#` (intToInt16# (r# `neInt16#` zero#))) + !k# = s# `andInt16#` y# + !r# = x# `remInt16#` y# + +{-# INLINE [0] modInt32# #-} +modInt32# :: Int32# -> Int32# -> Int32# +x# `modInt32#` y# = r# `plusInt32#` k# + where + zero# = intToInt32# 0# + x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y) + x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y) + notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x)) + -- See Note [modInt# implementation] + !yn# = intToInt32# (y# `ltInt32#` zero#) + !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#) + !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn# + !s# = zero# `subInt32#` ((c0# `orInt32#` c1#) `andInt32#` (intToInt32# (r# `neInt32#` zero#))) + !k# = s# `andInt32#` y# + !r# = x# `remInt32#` y# + +-- Note [modInt# implementation] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Similarly to divInt# (see Note [divInt# implementation]), we can derive the +-- branchless implementation of modInt# as follows: +-- +-- = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) || +-- isTrue# (x# <# 0#) && isTrue# (y# ># 0#) +-- then if isTrue# (r# /=# 0#) then r# +# y# else 0# +-- else r# +-- where +-- r# = x# `remInt#` y# +-- +-- ===> { Introduce constant k# } +-- +-- r# +# k# +-- where +-- k# = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) || +-- isTrue# (x# <# 0#) && isTrue# (y# ># 0#) +-- then if isTrue# (r# /=# 0#) then y# else 0# +-- else 0# +-- r# = x# `remInt#` y# +-- +-- ===> { Compute using Bool# } +-- +-- r# +# k# +-- where +-- yn# = y# <# 0# -- we don't need to consider y# ==# 0# +-- c0# = (x# <# 0#) &&# (notI# yn#) +-- c1# = (x# ># 0#) &&# yn# +-- k# = if isTrue# ((c0# ||# c1#) &&# (r# /=# 0#)) +-- then y# +-- else 0# +-- r# = x# `remInt#` y# +-- +-- ===> { Select y# or 0# in branchless way } +-- +-- r# +# k# +-- where +-- yn# = y# <# 0# +-- c0# = (x# <# 0#) &&# (notI# yn#) +-- c1# = (x# ># 0#) &&# yn# +-- -- s# is either equal to: +-- -- 0# (00..00b) +-- -- -1# (11..11b) +-- -- So we can AND s# with y# +-- s# = 0# -# ((c0# ||# c1#) &&# (r# /=# 0#)) +-- k# = s# &&# y# +-- r# = x# `remInt#` y# + +{-# INLINE [0] divModInt# #-} +divModInt# :: Int# -> Int# -> (# Int#, Int# #) +x# `divModInt#` y# = case (x# +# bias#) `quotRemInt#` y# of + (# q#, r# #) -> (# q# -# hard#, r# +# k# #) + where + -- See Note [divModInt# implementation] + !yn# = y# <# 0# + !c0# = (x# <# 0#) `andI#` (notI# yn#) + !c1# = (x# ># 0#) `andI#` yn# + !bias# = c0# -# c1# + !hard# = c0# `orI#` c1# + !s# = 0# -# hard# + !k# = (s# `andI#` y#) -# bias# + +{-# INLINE [0] divModInt8# #-} +divModInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #) +x# `divModInt8#` y# = case (x# `plusInt8#` bias#) `quotRemInt8#` y# of + (# q#, r# #) -> (# q# `subInt8#` hard#, r# `plusInt8#` k# #) + where + zero# = intToInt8# 0# + x `andInt8#` y = word8ToInt8# (int8ToWord8# x `andWord8#` int8ToWord8# y) + x `orInt8#` y = word8ToInt8# (int8ToWord8# x `orWord8#` int8ToWord8# y) + notInt8# x = word8ToInt8# (notWord8# (int8ToWord8# x)) + -- See Note [divModInt# implementation] + !yn# = intToInt8# (y# `ltInt8#` zero#) + !c0# = intToInt8# (x# `ltInt8#` zero#) `andInt8#` (notInt8# yn#) + !c1# = intToInt8# (x# `gtInt8#` zero#) `andInt8#` yn# + !bias# = c0# `subInt8#` c1# + !hard# = c0# `orInt8#` c1# + !s# = zero# `subInt8#` hard# + !k# = (s# `andInt8#` y#) `subInt8#` bias# + +{-# INLINE [0] divModInt16# #-} +divModInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #) +x# `divModInt16#` y# = case (x# `plusInt16#` bias#) `quotRemInt16#` y# of + (# q#, r# #) -> (# q# `subInt16#` hard#, r# `plusInt16#` k# #) + where + zero# = intToInt16# 0# + x `andInt16#` y = word16ToInt16# (int16ToWord16# x `andWord16#` int16ToWord16# y) + x `orInt16#` y = word16ToInt16# (int16ToWord16# x `orWord16#` int16ToWord16# y) + notInt16# x = word16ToInt16# (notWord16# (int16ToWord16# x)) + -- See Note [divModInt# implementation] + !yn# = intToInt16# (y# `ltInt16#` zero#) + !c0# = intToInt16# (x# `ltInt16#` zero#) `andInt16#` (notInt16# yn#) + !c1# = intToInt16# (x# `gtInt16#` zero#) `andInt16#` yn# + !bias# = c0# `subInt16#` c1# + !hard# = c0# `orInt16#` c1# + !s# = zero# `subInt16#` hard# + !k# = (s# `andInt16#` y#) `subInt16#` bias# + +{-# INLINE [0] divModInt32# #-} +divModInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #) +x# `divModInt32#` y# = case (x# `plusInt32#` bias#) `quotRemInt32#` y# of + (# q#, r# #) -> (# q# `subInt32#` hard#, r# `plusInt32#` k# #) + where + zero# = intToInt32# 0# + x `andInt32#` y = word32ToInt32# (int32ToWord32# x `andWord32#` int32ToWord32# y) + x `orInt32#` y = word32ToInt32# (int32ToWord32# x `orWord32#` int32ToWord32# y) + notInt32# x = word32ToInt32# (notWord32# (int32ToWord32# x)) + -- See Note [divModInt# implementation] + !yn# = intToInt32# (y# `ltInt32#` zero#) + !c0# = intToInt32# (x# `ltInt32#` zero#) `andInt32#` (notInt32# yn#) + !c1# = intToInt32# (x# `gtInt32#` zero#) `andInt32#` yn# + !bias# = c0# `subInt32#` c1# + !hard# = c0# `orInt32#` c1# + !s# = zero# `subInt32#` hard# + !k# = (s# `andInt32#` y#) `subInt32#` bias# + +-- Note [divModInt# implementation] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- divModInt# is written by deriving the following code similarly to divInt# and +-- modInt# (see Note [divInt# implementation] and Note [modInt# +-- implementation]). +-- +-- x# `divModInt#` y# +-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) = +-- case (x# -# 1#) `quotRemInt#` y# of +-- (# q, r #) -> (# q -# 1#, r +# y# +# 1# #) +-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) = +-- case (x# +# 1#) `quotRemInt#` y# of +-- (# q, r #) -> (# q -# 1#, r +# y# -# 1# #) +-- | otherwise = +-- x# `quotRemInt#` y# +-- +-- ===> { Introduce constants } +-- +-- case (x# +# bias#) `quotRemInt#` y# of +-- (# q#, r# #) -> (# q# -# hard#, r# +# k# #) +-- where +-- (bias#,hard#,k#) +-- | isTrue# (x# ># 0#) && isTrue# (y# <# 0#) = (-1#, 1#, y#+1#) +-- | isTrue# (x# <# 0#) && isTrue# (y# ># 0#) = ( 1#, 1#, y#-1#) +-- | otherwise = ( 0#, 0#, 0#-0#) +-- +-- ===> { Compute using Bool# } +-- +-- case (x# +# bias#) `quotRemInt#` y# of +-- (# q#, r# #) -> (# q# -# hard#, r# +# k# #) +-- where +-- yn# = y# <# 0# +-- c0# = (x# <# 0#) `andI#` (notI# yn#) +-- c1# = (x# ># 0#) `andI#` yn# +-- bias# = c0# -# c1# +-- hard# = c0# `orI#` c1# +-- s# = 0# -# hard# +-- k# = (s# `andI#` y#) -# bias# +-- + +{- ************************************************************* +* * +* Constraint tuples * +* * +************************************************************* -} + +type CTuple0 = (() :: Constraint) +type CTuple1 = CSolo + +class CUnit +class a => CSolo a +class (c1, c2) => CTuple2 c1 c2 +class (c1, c2, c3) => CTuple3 c1 c2 c3 +class (c1, c2, c3, c4) => CTuple4 c1 c2 c3 c4 +class (c1, c2, c3, c4, c5) => CTuple5 c1 c2 c3 c4 c5 +class (c1, c2, c3, c4, c5, c6) => CTuple6 c1 c2 c3 c4 c5 c6 +class (c1, c2, c3, c4, c5, c6, c7) => CTuple7 c1 c2 c3 c4 c5 c6 c7 +class (c1, c2, c3, c4, c5, c6, c7, c8) => CTuple8 c1 c2 c3 c4 c5 c6 c7 c8 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9) + => CTuple9 c1 c2 c3 c4 c5 c6 c7 c8 c9 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) + => CTuple10 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) + => CTuple11 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) + => CTuple12 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) + => CTuple13 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) + => CTuple14 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) + => CTuple15 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) + => CTuple16 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17) + => CTuple17 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17,c18) + => CTuple18 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19) + => CTuple19 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20) + => CTuple20 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21) + => CTuple21 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22) + => CTuple22 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23) + => CTuple23 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24) + => CTuple24 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25) + => CTuple25 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) + => CTuple26 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) + => CTuple27 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) + => CTuple28 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) + => CTuple29 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) + => CTuple30 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31) + => CTuple31 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32) + => CTuple32 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33) + => CTuple33 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34) + => CTuple34 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35) + => CTuple35 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36) + => CTuple36 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37) + => CTuple37 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38) + => CTuple38 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39) + => CTuple39 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) + => CTuple40 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) + => CTuple41 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) + => CTuple42 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) + => CTuple43 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) + => CTuple44 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45) + => CTuple45 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46) + => CTuple46 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47) + => CTuple47 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48) + => CTuple48 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49) + => CTuple49 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50) + => CTuple50 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51) + => CTuple51 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52) + => CTuple52 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53) + => CTuple53 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) + => CTuple54 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) + => CTuple55 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) + => CTuple56 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) + => CTuple57 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) + => CTuple58 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59) + => CTuple59 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60) + => CTuple60 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61) + => CTuple61 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62) + => CTuple62 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62, c63) + => CTuple63 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 c63 +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62, c63, c64) + => CTuple64 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 c63 c64 + +instance CUnit +instance a => CSolo a +instance (c1, c2) => CTuple2 c1 c2 +instance (c1, c2, c3) => CTuple3 c1 c2 c3 +instance (c1, c2, c3, c4) => CTuple4 c1 c2 c3 c4 +instance (c1, c2, c3, c4, c5) => CTuple5 c1 c2 c3 c4 c5 +instance (c1, c2, c3, c4, c5, c6) => CTuple6 c1 c2 c3 c4 c5 c6 +instance (c1, c2, c3, c4, c5, c6, c7) => CTuple7 c1 c2 c3 c4 c5 c6 c7 +instance (c1, c2, c3, c4, c5, c6, c7, c8) => CTuple8 c1 c2 c3 c4 c5 c6 c7 c8 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9) + => CTuple9 c1 c2 c3 c4 c5 c6 c7 c8 c9 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) + => CTuple10 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) + => CTuple11 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) + => CTuple12 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) + => CTuple13 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) + => CTuple14 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) + => CTuple15 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) + => CTuple16 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17) + => CTuple17 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17,c18) + => CTuple18 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19) + => CTuple19 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20) + => CTuple20 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21) + => CTuple21 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22) + => CTuple22 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23) + => CTuple23 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24) + => CTuple24 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25) + => CTuple25 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) + => CTuple26 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) + => CTuple27 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) + => CTuple28 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) + => CTuple29 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) + => CTuple30 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31) + => CTuple31 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32) + => CTuple32 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33) + => CTuple33 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34) + => CTuple34 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35) + => CTuple35 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36) + => CTuple36 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37) + => CTuple37 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38) + => CTuple38 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39) + => CTuple39 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) + => CTuple40 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) + => CTuple41 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) + => CTuple42 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) + => CTuple43 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) + => CTuple44 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45) + => CTuple45 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46) + => CTuple46 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47) + => CTuple47 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48) + => CTuple48 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49) + => CTuple49 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50) + => CTuple50 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51) + => CTuple51 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52) + => CTuple52 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53) + => CTuple53 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) + => CTuple54 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) + => CTuple55 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) + => CTuple56 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) + => CTuple57 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) + => CTuple58 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59) + => CTuple59 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60) + => CTuple60 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61) + => CTuple61 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62) + => CTuple62 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62, c63) + => CTuple63 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 c63 +instance (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62, c63, c64) + => CTuple64 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 + c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 + c37 c38 c39 c40 c41 c42 c43 c44 c45 c46 c47 c48 c49 c50 c51 c52 c53 c54 + c55 c56 c57 c58 c59 c60 c61 c62 c63 c64 diff --git a/GHC/Debug.hs b/GHC/Debug.hs --- a/GHC/Debug.hs +++ b/GHC/Debug.hs @@ -1,10 +1,15 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes #-} +-- | Users should not import this module. It is GHC internal only. + module GHC.Debug ( debugLn, debugErrLn ) where import GHC.Prim import GHC.Types + +-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base +-- (This module uses the empty tuple.) import GHC.Tuple () debugLn :: [Char] -> IO () diff --git a/GHC/Magic.hs b/GHC/Magic.hs --- a/GHC/Magic.hs +++ b/GHC/Magic.hs @@ -4,6 +4,8 @@ {-# LANGUAGE DataKinds #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneKindSignatures #-} +{-# OPTIONS_HADDOCK print-explicit-runtime-reps #-} ----------------------------------------------------------------------------- -- | @@ -11,7 +13,7 @@ -- 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) -- @@ -22,7 +24,7 @@ -- ----------------------------------------------------------------------------- -module GHC.Magic ( inline, noinline, lazy, oneShot, runRW# ) where +module GHC.Magic ( inline, noinline, lazy, oneShot, runRW#, DataToTag(..) ) where -------------------------------------------------- -- See Note [magicIds] in GHC.Types.Id.Make @@ -31,8 +33,8 @@ -- 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) -import GHC.Types (RuntimeRep, TYPE) +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 @@ -56,8 +58,8 @@ -- | 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 noinline #-} noinline :: a -> a +{-# NOINLINE noinline #-} -- noinline is inlined manually in CorePrep noinline x = x -- | The 'lazy' function restrains strictness analysis a little. The @@ -77,6 +79,7 @@ -- 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 GHC.Types.Id.Make; in both cases to nothing at all. @@ -94,7 +97,7 @@ -- 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 +-- '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). @@ -108,7 +111,7 @@ -- semantically undesirable floating. `runRW#` is inlined, but only very late -- in compilation after all floating is complete. --- 'runRW#' is representation polymorphic: the result may have a lifted or +-- 'runRW#' is levity-polymorphic: the result may have a lifted or -- unlifted type. runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). @@ -116,3 +119,21 @@ -- See Note [runRW magic] in GHC.CoreToStg.Prep. {-# NOINLINE runRW# #-} -- runRW# is inlined manually in CorePrep runRW# m = m realWorld# + +-- | @'dataToTag#'@ evaluates its argument and returns the index +-- (starting at zero) of the constructor used to produce that +-- argument. Any algebraic data type with all of its constructors +-- in scope may be used with @dataToTag#@. +-- +-- >>> dataToTag# (Left ()) +-- 0# +-- >>> dataToTag# (Right undefined) +-- 1# +type DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint +-- See Note [DataToTag overview] in GHC.Tc.Instance.Class. +-- +-- Ignoring DatatypeContexts, any generated DataToTag instance is +-- equivalent to a function the user could have written themselves. +-- So it does not get its own Unsafe module, unlike WithDict. +class DataToTag a where + dataToTag# :: a -> Int# diff --git a/GHC/Magic/Dict.hs b/GHC/Magic/Dict.hs new file mode 100644 --- /dev/null +++ b/GHC/Magic/Dict.hs @@ -0,0 +1,72 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ImpredicativeTypes #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE AllowAmbiguousTypes #-} -- See Note [withDict has an ambiguous type] +{-# LANGUAGE Unsafe #-} + +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Magic.Dict +-- Copyright : (c) The University of Glasgow 2009 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : ghc-devs@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- Defines the 'withDict' function. For more information, see +-- @Note [withDict]@ in "GHC.Tc.Instance.Class" in GHC. +-- The definition of 'withDict' is located in a separate module from +-- "GHC.Magic" because 'withDict' is @Unsafe@ (it threatens type class +-- coherence) while "GHC.Magic" is @Trustworthy@. +-- +-- Use "GHC.Exts" from the @base@ package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.Magic.Dict ( + WithDict( withDict ) + ) where + +import GHC.Types (RuntimeRep, TYPE) + +-- | The constraint @'WithDict' cls meth@ can be solved when evidence for +-- the constraint @cls@ can be provided in the form of a dictionary of +-- type @meth@. This requires @cls@ to be a class constraint whose single +-- method has type @meth@. +-- +-- For more (important) details on how this works, see +-- @Note [withDict]@ in "GHC.Tc.Instance.Class" in GHC. +-- +-- @since 0.9.0 +class WithDict cls meth where + -- @'withDict' d f@ provides a way to call a type-class–overloaded function + -- @f@ by applying it to the supplied dictionary @d@. + -- + -- 'withDict' can only be used if the type class has a single method with no + -- superclasses. + -- + -- @since 0.9.0 + withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r + +{- Note [withDict has an ambiguous type] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +The type of `withDict` is ambiguous. Consider + foo :: forall cls meth. WithDict cls meth + => forall rr (r::rr). meth -> (cls => r) -> r + foo m k = withDict m k + +If we instantiate `withDict` with fresh unification variables, including cls0 for cls, +there is nothing that forces the `cls` Wanted from the call to `k` to unify with the +`cls0` Given from the call to `withDict`. You have to give it a class argument: + + foo m k = withDict @cls m k + +That's fine. But it means we need -XAllowAmbiguousTypes for the withDict definition, +at least with deep subsumption. +-} diff --git a/GHC/Prim/Exception.hs b/GHC/Prim/Exception.hs --- a/GHC/Prim/Exception.hs +++ b/GHC/Prim/Exception.hs @@ -1,11 +1,10 @@ -{-# LANGUAGE GHCForeignImportPrim #-} -{-# LANGUAGE UnliftedFFITypes #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE EmptyCase #-} -- | Primitive exceptions. +-- +-- Users should not import this module. It is GHC internal only. module GHC.Prim.Exception ( raiseOverflow , raiseUnderflow @@ -14,39 +13,31 @@ where import GHC.Prim -import GHC.Magic +-- 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 - -foreign import prim "stg_raiseOverflowzh" raiseOverflow# :: State# RealWorld -> (# State# RealWorld, (# #) #) -foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, (# #) #) -foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, (# #) #) - --- We give a bottoming demand signature to 'raiseOverflow', 'raiseUnderflow' and --- 'raiseDivZero' in "GHC.Core.Make". NOINLINE pragmas are necessary because if --- we ever inlined them we would lose that information. +-- +-- See also: Note [Wired-in exceptions are not CAFfy] in GHC.Core.Make. -- | Raise 'GHC.Exception.Type.overflowException' raiseOverflow :: a -{-# NOINLINE raiseOverflow #-} -raiseOverflow = runRW# (\s -> case raiseOverflow# s of (# _, _ #) -> let x = x in x) +raiseOverflow = raiseOverflow# (# #) -- | Raise 'GHC.Exception.Type.underflowException' raiseUnderflow :: a -{-# NOINLINE raiseUnderflow #-} -raiseUnderflow = runRW# (\s -> case raiseUnderflow# s of (# _, _ #) -> let x = x in x) +raiseUnderflow = raiseUnderflow# (# #) -- | Raise 'GHC.Exception.Type.divZeroException' raiseDivZero :: a -{-# NOINLINE raiseDivZero #-} -raiseDivZero = runRW# (\s -> case raiseDivZero# s of (# _, _ #) -> let x = x in x) +raiseDivZero = raiseDivZero# (# #) diff --git a/GHC/Prim/Ext.hs b/GHC/Prim/Ext.hs --- a/GHC/Prim/Ext.hs +++ b/GHC/Prim/Ext.hs @@ -5,6 +5,8 @@ {-# 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" @@ -16,6 +18,9 @@ -- | 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 @@ -26,41 +31,22 @@ -- are described over there. module GHC.Prim.Ext ( - -- 64-bit bit aliases - INT64 - , WORD64 + -- * Misc + getThreadAllocationCounter# -- * Delay\/wait operations #if defined(mingw32_HOST_OS) , asyncRead# , asyncWrite# , asyncDoProc# #endif - -- * Misc - , getThreadAllocationCounter# ) where import GHC.Prim -import GHC.Types () -- Make implicit dependency known to build system -default () -- Double and Integer aren't available yet - ------------------------------------------------------------------------- --- 64-bit bit aliases ------------------------------------------------------------------------- - -type INT64 = -#if WORD_SIZE_IN_BITS < 64 - Int64# -#else - Int# -#endif +-- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base +import GHC.Types () -type WORD64 = -#if WORD_SIZE_IN_BITS < 64 - Word64# -#else - Word# -#endif +default () -- Double and Integer aren't available yet ------------------------------------------------------------------------ -- Delay/wait operations @@ -102,4 +88,162 @@ -- | Retrieves the allocation counter for the current thread. foreign import prim "stg_getThreadAllocationCounterzh" getThreadAllocationCounter# :: State# RealWorld - -> (# State# RealWorld, INT64 #) + -> (# State# RealWorld, Int64# #) + +------------------------------------------------------------------------ +-- Rules for primops that don't need to be built-in +------------------------------------------------------------------------ + +-- All these rules are used to remove useless casts: +-- +-- 1. passing through a type with at least the same bit size: +-- e.g. Int8# -> Int# -> Int8# +-- ==> id +-- +-- 2. passing through a (un)signed type of the same bit size: +-- e.g. Word# -> Int# -> Word# +-- ==> id +-- +-- 3. one of the previous cases with signedness change: +-- e.g. Int8# -> Int# -> Word# -> Word8# +-- ==> Int8# -> Word8# +-- + + +-- case 1: +-- ~~~~~~~ + +{-# RULES + +"Int8# -> Int# -> Int8#" + forall x . intToInt8# (int8ToInt# x) = x + +"Int16# -> Int# -> Int16#" + forall x . intToInt16# (int16ToInt# x) = x + +"Int32# -> Int# -> Int32#" + forall x . intToInt32# (int32ToInt# x) = x + + +"Word8# -> Word# -> Word8#" + forall x . wordToWord8# (word8ToWord# x) = x + +"Word16# -> Word# -> Word16#" + forall x . wordToWord16# (word16ToWord# x) = x + +"Word32# -> Word# -> Word32#" + forall x . wordToWord32# (word32ToWord# x) = x + + +"Int# -> Int64# -> Int#" + forall x . int64ToInt# (intToInt64# x) = x + +"Word# -> Word64# -> Word#" + forall x . word64ToWord# (wordToWord64# x) = x + +#-} + +#if WORD_SIZE_IN_BITS == 64 +{-# RULES + +"Int64# -> Int# -> Int64#" + forall x . intToInt64# (int64ToInt# x) = x + +"Word64# -> Word# -> Word64#" + forall x . wordToWord64# (word64ToWord# x) = x + +#-} +#endif + + +-- case 2: +-- ~~~~~~~ + +{-# RULES + +"Word# -> Int# -> Word#" + forall x . int2Word# (word2Int# x) = x + +"Int# -> Word# -> Int#" + forall x . word2Int# (int2Word# x) = x + +"Int8# -> Word8# -> Int8#" + forall x . word8ToInt8# (int8ToWord8# x) = x + +"Word8# -> Int8# -> Word8#" + forall x . int8ToWord8# (word8ToInt8# x) = x + +"Int16# -> Word16# -> Int16#" + forall x . word16ToInt16# (int16ToWord16# x) = x + +"Word16# -> Int16# -> Word16#" + forall x . int16ToWord16# (word16ToInt16# x) = x + +"Int32# -> Word32# -> Int32#" + forall x . word32ToInt32# (int32ToWord32# x) = x + +"Word32# -> Int32# -> Word32#" + forall x . int32ToWord32# (word32ToInt32# x) = x + +"Int64# -> Word64# -> Int64#" + forall x . word64ToInt64# (int64ToWord64# x) = x + +"Word64# -> Int64# -> Word64#" + forall x . int64ToWord64# (word64ToInt64# x) = x + +#-} + +-- case 3: +-- ~~~~~~~ + +{-# RULES + +"Int8# -> Int# -> Word# -> Word8#" + forall x . wordToWord8# (int2Word# (int8ToInt# x)) = int8ToWord8# x + +"Int16# -> Int# -> Word# -> Word16#" + forall x . wordToWord16# (int2Word# (int16ToInt# x)) = int16ToWord16# x + +"Int32# -> Int# -> Word# -> Word32#" + forall x . wordToWord32# (int2Word# (int32ToInt# x)) = int32ToWord32# x + +"Word8# -> Word# -> Int# -> Int8#" + forall x . intToInt8# (word2Int# (word8ToWord# x)) = word8ToInt8# x + +"Word16# -> Word# -> Int# -> Int16#" + forall x . intToInt16# (word2Int# (word16ToWord# x)) = word16ToInt16# x + +"Word32# -> Word# -> Int# -> Int32#" + forall x . intToInt32# (word2Int# (word32ToWord# x)) = word32ToInt32# x + +"Word# -> Word64# -> Int64# -> Int#" + forall x. int64ToInt# (word64ToInt64# (wordToWord64# x)) = word2Int# x + +"Int# -> Int64# -> Word64# -> Word#" + forall x. word64ToWord# (int64ToWord64# (intToInt64# x)) = int2Word# x + +#-} + +#if WORD_SIZE_IN_BITS == 64 +{-# RULES +"Int64# -> Int# -> Word# -> Word64#" + forall x . wordToWord64# (int2Word# (int64ToInt# x)) = int64ToWord64# x + +"Word64# -> Word# -> Int# -> Int64#" + forall x . intToInt64# (word2Int# (word64ToWord# x)) = word64ToInt64# x +#-} +#endif + + +-- Push downcast into bitwise operations +{-# RULES +"word64ToWord#/and64#" + forall x y . word64ToWord# (and64# x y) = and# (word64ToWord# x) (word64ToWord# y) + +"word64ToWord#/or64#" + forall x y . word64ToWord# (or64# x y) = or# (word64ToWord# x) (word64ToWord# y) + +"word64ToWord#/xor64#" + forall x y . word64ToWord# (xor64# x y) = xor# (word64ToWord# x) (word64ToWord# y) + +#-} diff --git a/GHC/Prim/Panic.hs b/GHC/Prim/Panic.hs --- a/GHC/Prim/Panic.hs +++ b/GHC/Prim/Panic.hs @@ -4,17 +4,21 @@ {-# 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 + , absentError, absentConstraintError ) where import GHC.Prim import GHC.Magic +import GHC.Types( Type ) default () -- Double and Integer aren't available yet @@ -93,7 +97,7 @@ -- | Displays "Oops! Entered absent arg" ++ errormsg and exits the program. {-# NOINLINE absentError #-} -absentError :: Addr# -> a +absentError :: forall (a :: Type). Addr# -> a absentError errmsg = runRW# (\s -> case stg_absentError# errmsg s of @@ -101,3 +105,15 @@ -- use an empty case lest the pattern match -- checker squawks. let x = x in x) + +{-# NOINLINE absentConstraintError #-} +absentConstraintError :: forall (a :: Type). Addr# -> a +-- We want to give this the type +-- forall (a :: Constraint). Addr# -> a +-- but Haskell source code doesn't allow functions that return Constraint +-- So in this module we lie about the type. This is fine because +-- absentConstraintError is a wired-in Id with the desired Constraint-kinded +-- type; the type in the interface file is never looked at. +-- The only purpose of this definition is to give a function to call, +-- and for that purpose, delegating to absentError is fine. +absentConstraintError errmsg = absentError errmsg diff --git a/GHC/Prim/PtrEq.hs b/GHC/Prim/PtrEq.hs new file mode 100644 --- /dev/null +++ b/GHC/Prim/PtrEq.hs @@ -0,0 +1,153 @@ +{-# LANGUAGE Unsafe #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE PolyKinds #-} + +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Prim.PtrEq +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : ghc-devs@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- Comparing underlying pointers for equality. +-- +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.Prim.PtrEq + ( reallyUnsafePtrEquality, + unsafePtrEquality#, + sameArray#, + sameMutableArray#, + sameSmallArray#, + sameSmallMutableArray#, + sameByteArray#, + sameMutableByteArray#, + sameMutVar#, + sameTVar#, + sameMVar#, + sameIOPort#, + samePromptTag#, + eqStableName# + ) where + +import GHC.Prim +import GHC.Types -- Also make implicit dependency known to build system + ( RuntimeRep(BoxedRep), UnliftedType ) +default () -- Double and Integer aren't available yet + +{- ********************************************************************** +* * +* Pointer equality * +* * +********************************************************************** -} + +{- Note [Pointer equality operations] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Many primitive types - such as Array#, ByteArray#, MVar#, ... - are boxed: +they are represented by pointers to the underlying data. It is thus possible +to directly compare these pointers for equality, as opposed to comparing +the underlying data that the pointers refer to (for instance, comparing +two arrays element-wise). + +To do this, GHC provides the primop reallyUnsafePtrEquality#, which is +both levity-polymorphic and heterogeneous. As its name indicates, it is an +unsafe operation which can yield unpredictable results, as explained in +Note [Pointer comparison operations] in primops.txt.pp + +For a more user-friendly interface, this module defines specialisations of +the reallyUnsafePtrEquality# primop at various primitive types, such as +Array#, ByteArray#, MVar#, ... +-} + +-- | Compare the underlying pointers of two values for equality. +-- +-- Returns @1@ if the pointers are equal and @0@ otherwise. +-- +-- The two values must be of the same type, of kind 'Type'. +-- See also 'GHC.Exts.reallyUnsafePtrEquality#', which doesn't have +-- such restrictions. +reallyUnsafePtrEquality :: a -> a -> Int# +reallyUnsafePtrEquality = reallyUnsafePtrEquality# +-- See Note [Pointer comparison operations] +-- in primops.txt.pp + +-- | Compare the underlying pointers of two unlifted values for equality. +-- +-- This is less dangerous than 'reallyUnsafePtrEquality', +-- since the arguments are guaranteed to be evaluated. +-- This means there is no risk of accidentally comparing +-- a thunk. +-- It's however still more dangerous than e.g. 'sameArray#'. +-- +unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int# +unsafePtrEquality# = reallyUnsafePtrEquality# +-- See Note [Pointer comparison operations] +-- in primops.txt.pp + +-- | Compare the underlying pointers of two arrays. +sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int# +sameArray# = unsafePtrEquality# + +-- | Compare the underlying pointers of two mutable arrays. +sameMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int# +sameMutableArray# = unsafePtrEquality# + +-- | Compare the underlying pointers of two small arrays. +sameSmallArray# :: forall {l} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int# +sameSmallArray# = unsafePtrEquality# + +-- | Compare the underlying pointers of two small mutable arrays. +sameSmallMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int# +sameSmallMutableArray# = unsafePtrEquality# + +-- | Compare the pointers of two byte arrays. +sameByteArray# :: ByteArray# -> ByteArray# -> Int# +sameByteArray# = unsafePtrEquality# + +-- | Compare the underlying pointers of two mutable byte arrays. +sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# +sameMutableByteArray# = unsafePtrEquality# + +-- | Compare the underlying pointers of two 'MutVar#'s. +sameMutVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int# +sameMutVar# = unsafePtrEquality# + +-- | Compare the underlying pointers of two 'TVar#'s. +sameTVar# :: forall {l} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int# +sameTVar# = unsafePtrEquality# + +-- | Compare the underlying pointers of two 'MVar#'s. +sameMVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int# +sameMVar# = unsafePtrEquality# + +-- | Compare the underlying pointers of two 'IOPort#'s. +sameIOPort# :: forall {l} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int# +sameIOPort# = unsafePtrEquality# + +-- | Compare the underlying pointers of two 'PromptTag#'s. +samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int# +samePromptTag# = unsafePtrEquality# + +-- Note [Comparing stable names] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- A StableName# is actually a pointer to a stable name object (SNO) +-- containing an index into the stable name table (SNT). We +-- used to compare StableName#s by following the pointers to the +-- SNOs and checking whether they held the same SNT indices. However, +-- this is not necessary: there is a one-to-one correspondence +-- between SNOs and entries in the SNT, so simple pointer equality +-- does the trick. + +-- | Compare two stable names for equality. +eqStableName# :: forall {k} {l} (a :: TYPE (BoxedRep k)) (b :: TYPE (BoxedRep l)) + . StableName# a -> StableName# b -> Int# +eqStableName# = unsafePtrEquality# diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs --- a/GHC/PrimopWrappers.hs +++ b/GHC/PrimopWrappers.hs @@ -1,1926 +1,2213 @@ -{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-} -{-# OPTIONS_GHC -Wno-deprecations -O0 #-} -module GHC.PrimopWrappers where -import qualified GHC.Prim -import GHC.Tuple () -import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, 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 (+#) #-} -(+#) :: 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# :: Word# -> 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# :: Word# -> Word# -> Word# -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# :: Word# -> Word# -> Word# -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# :: Word# -> Word# -clz64# a1 = (GHC.Prim.clz64#) a1 -{-# NOINLINE clz# #-} -clz# :: Word# -> Word# -clz# a1 = (GHC.Prim.clz#) a1 -{-# NOINLINE ctz8# #-} -ctz8# :: Word# -> Word# -ctz8# a1 = (GHC.Prim.ctz8#) a1 -{-# NOINLINE ctz16# #-} -ctz16# :: Word# -> Word# -ctz16# a1 = (GHC.Prim.ctz16#) a1 -{-# NOINLINE ctz32# #-} -ctz32# :: Word# -> Word# -ctz32# a1 = (GHC.Prim.ctz32#) a1 -{-# NOINLINE ctz64# #-} -ctz64# :: Word# -> Word# -ctz64# a1 = (GHC.Prim.ctz64#) a1 -{-# NOINLINE ctz# #-} -ctz# :: Word# -> Word# -ctz# a1 = (GHC.Prim.ctz#) a1 -{-# NOINLINE byteSwap16# #-} -byteSwap16# :: Word# -> Word# -byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1 -{-# NOINLINE byteSwap32# #-} -byteSwap32# :: Word# -> Word# -byteSwap32# a1 = (GHC.Prim.byteSwap32#) a1 -{-# NOINLINE byteSwap64# #-} -byteSwap64# :: Word# -> Word# -byteSwap64# a1 = (GHC.Prim.byteSwap64#) a1 -{-# NOINLINE byteSwap# #-} -byteSwap# :: Word# -> Word# -byteSwap# a1 = (GHC.Prim.byteSwap#) a1 -{-# NOINLINE 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# :: Word# -> Word# -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 (+##) #-} -(+##) :: 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# -> (# Int#,Int# #) -decodeDouble_Int64# a1 = (GHC.Prim.decodeDouble_Int64#) a1 -{-# NOINLINE gtFloat# #-} -gtFloat# :: Float# -> Float# -> Int# -gtFloat# a1 a2 = (GHC.Prim.gtFloat#) a1 a2 -{-# NOINLINE geFloat# #-} -geFloat# :: Float# -> Float# -> Int# -geFloat# a1 a2 = (GHC.Prim.geFloat#) a1 a2 -{-# NOINLINE eqFloat# #-} -eqFloat# :: Float# -> Float# -> Int# -eqFloat# a1 a2 = (GHC.Prim.eqFloat#) a1 a2 -{-# NOINLINE neFloat# #-} -neFloat# :: Float# -> Float# -> Int# -neFloat# a1 a2 = (GHC.Prim.neFloat#) a1 a2 -{-# NOINLINE ltFloat# #-} -ltFloat# :: Float# -> Float# -> Int# -ltFloat# a1 a2 = (GHC.Prim.ltFloat#) a1 a2 -{-# NOINLINE leFloat# #-} -leFloat# :: Float# -> Float# -> Int# -leFloat# a1 a2 = (GHC.Prim.leFloat#) a1 a2 -{-# NOINLINE plusFloat# #-} -plusFloat# :: Float# -> Float# -> Float# -plusFloat# a1 a2 = (GHC.Prim.plusFloat#) a1 a2 -{-# NOINLINE minusFloat# #-} -minusFloat# :: Float# -> Float# -> Float# -minusFloat# a1 a2 = (GHC.Prim.minusFloat#) a1 a2 -{-# NOINLINE timesFloat# #-} -timesFloat# :: Float# -> Float# -> Float# -timesFloat# a1 a2 = (GHC.Prim.timesFloat#) a1 a2 -{-# NOINLINE divideFloat# #-} -divideFloat# :: Float# -> Float# -> Float# -divideFloat# a1 a2 = (GHC.Prim.divideFloat#) a1 a2 -{-# NOINLINE negateFloat# #-} -negateFloat# :: Float# -> Float# -negateFloat# a1 = (GHC.Prim.negateFloat#) a1 -{-# NOINLINE 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 newArray# #-} -newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) -newArray# a1 a2 a3 = (GHC.Prim.newArray#) a1 a2 a3 -{-# NOINLINE sameMutableArray# #-} -sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# -sameMutableArray# a1 a2 = (GHC.Prim.sameMutableArray#) a1 a2 -{-# NOINLINE readArray# #-} -readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readArray# a1 a2 a3 = (GHC.Prim.readArray#) a1 a2 a3 -{-# NOINLINE writeArray# #-} -writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s -writeArray# a1 a2 a3 a4 = (GHC.Prim.writeArray#) a1 a2 a3 a4 -{-# NOINLINE sizeofArray# #-} -sizeofArray# :: Array# a -> Int# -sizeofArray# a1 = (GHC.Prim.sizeofArray#) a1 -{-# NOINLINE sizeofMutableArray# #-} -sizeofMutableArray# :: MutableArray# s a -> Int# -sizeofMutableArray# a1 = (GHC.Prim.sizeofMutableArray#) a1 -{-# NOINLINE indexArray# #-} -indexArray# :: Array# a -> Int# -> (# a #) -indexArray# a1 a2 = (GHC.Prim.indexArray#) a1 a2 -{-# NOINLINE unsafeFreezeArray# #-} -unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) -unsafeFreezeArray# a1 a2 = (GHC.Prim.unsafeFreezeArray#) a1 a2 -{-# NOINLINE unsafeThawArray# #-} -unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) -unsafeThawArray# a1 a2 = (GHC.Prim.unsafeThawArray#) a1 a2 -{-# NOINLINE copyArray# #-} -copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE copyMutableArray# #-} -copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE cloneArray# #-} -cloneArray# :: Array# a -> Int# -> Int# -> Array# a -cloneArray# a1 a2 a3 = (GHC.Prim.cloneArray#) a1 a2 a3 -{-# NOINLINE cloneMutableArray# #-} -cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) -cloneMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneMutableArray#) a1 a2 a3 a4 -{-# NOINLINE freezeArray# #-} -freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) -freezeArray# a1 a2 a3 a4 = (GHC.Prim.freezeArray#) a1 a2 a3 a4 -{-# NOINLINE thawArray# #-} -thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) -thawArray# a1 a2 a3 a4 = (GHC.Prim.thawArray#) a1 a2 a3 a4 -{-# NOINLINE casArray# #-} -casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casArray# a1 a2 a3 a4 a5 = (GHC.Prim.casArray#) a1 a2 a3 a4 a5 -{-# NOINLINE newSmallArray# #-} -newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #) -newSmallArray# a1 a2 a3 = (GHC.Prim.newSmallArray#) a1 a2 a3 -{-# NOINLINE sameSmallMutableArray# #-} -sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int# -sameSmallMutableArray# a1 a2 = (GHC.Prim.sameSmallMutableArray#) a1 a2 -{-# NOINLINE shrinkSmallMutableArray# #-} -shrinkSmallMutableArray# :: SmallMutableArray# s a -> Int# -> State# s -> State# s -shrinkSmallMutableArray# a1 a2 a3 = (GHC.Prim.shrinkSmallMutableArray#) a1 a2 a3 -{-# NOINLINE readSmallArray# #-} -readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readSmallArray# a1 a2 a3 = (GHC.Prim.readSmallArray#) a1 a2 a3 -{-# NOINLINE writeSmallArray# #-} -writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s -writeSmallArray# a1 a2 a3 a4 = (GHC.Prim.writeSmallArray#) a1 a2 a3 a4 -{-# NOINLINE sizeofSmallArray# #-} -sizeofSmallArray# :: SmallArray# a -> Int# -sizeofSmallArray# a1 = (GHC.Prim.sizeofSmallArray#) a1 -{-# NOINLINE sizeofSmallMutableArray# #-} -sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int# -sizeofSmallMutableArray# a1 = (GHC.Prim.sizeofSmallMutableArray#) a1 -{-# NOINLINE getSizeofSmallMutableArray# #-} -getSizeofSmallMutableArray# :: SmallMutableArray# s a -> State# s -> (# State# s,Int# #) -getSizeofSmallMutableArray# a1 a2 = (GHC.Prim.getSizeofSmallMutableArray#) a1 a2 -{-# NOINLINE indexSmallArray# #-} -indexSmallArray# :: SmallArray# a -> Int# -> (# a #) -indexSmallArray# a1 a2 = (GHC.Prim.indexSmallArray#) a1 a2 -{-# NOINLINE unsafeFreezeSmallArray# #-} -unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #) -unsafeFreezeSmallArray# a1 a2 = (GHC.Prim.unsafeFreezeSmallArray#) a1 a2 -{-# NOINLINE unsafeThawSmallArray# #-} -unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #) -unsafeThawSmallArray# a1 a2 = (GHC.Prim.unsafeThawSmallArray#) a1 a2 -{-# NOINLINE copySmallArray# #-} -copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE copySmallMutableArray# #-} -copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallMutableArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE cloneSmallArray# #-} -cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a -cloneSmallArray# a1 a2 a3 = (GHC.Prim.cloneSmallArray#) a1 a2 a3 -{-# NOINLINE cloneSmallMutableArray# #-} -cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) -cloneSmallMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneSmallMutableArray#) a1 a2 a3 a4 -{-# NOINLINE freezeSmallArray# #-} -freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #) -freezeSmallArray# a1 a2 a3 a4 = (GHC.Prim.freezeSmallArray#) a1 a2 a3 a4 -{-# NOINLINE thawSmallArray# #-} -thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) -thawSmallArray# a1 a2 a3 a4 = (GHC.Prim.thawSmallArray#) a1 a2 a3 a4 -{-# NOINLINE casSmallArray# #-} -casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casSmallArray# a1 a2 a3 a4 a5 = (GHC.Prim.casSmallArray#) a1 a2 a3 a4 a5 -{-# NOINLINE newByteArray# #-} -newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2 -{-# NOINLINE newPinnedByteArray# #-} -newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newPinnedByteArray# a1 a2 = (GHC.Prim.newPinnedByteArray#) a1 a2 -{-# NOINLINE newAlignedPinnedByteArray# #-} -newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -newAlignedPinnedByteArray# a1 a2 a3 = (GHC.Prim.newAlignedPinnedByteArray#) a1 a2 a3 -{-# NOINLINE isMutableByteArrayPinned# #-} -isMutableByteArrayPinned# :: MutableByteArray# s -> Int# -isMutableByteArrayPinned# a1 = (GHC.Prim.isMutableByteArrayPinned#) a1 -{-# NOINLINE isByteArrayPinned# #-} -isByteArrayPinned# :: ByteArray# -> Int# -isByteArrayPinned# a1 = (GHC.Prim.isByteArrayPinned#) 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 sameMutableByteArray# #-} -sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# -sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2 -{-# NOINLINE shrinkMutableByteArray# #-} -shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s -shrinkMutableByteArray# a1 a2 a3 = (GHC.Prim.shrinkMutableByteArray#) a1 a2 a3 -{-# NOINLINE resizeMutableByteArray# #-} -resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -resizeMutableByteArray# a1 a2 a3 = (GHC.Prim.resizeMutableByteArray#) a1 a2 a3 -{-# NOINLINE unsafeFreezeByteArray# #-} -unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) -unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2 -{-# NOINLINE sizeofByteArray# #-} -sizeofByteArray# :: ByteArray# -> Int# -sizeofByteArray# a1 = (GHC.Prim.sizeofByteArray#) a1 -{-# NOINLINE sizeofMutableByteArray# #-} -sizeofMutableByteArray# :: MutableByteArray# s -> Int# -sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1 -{-# NOINLINE 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 indexInt16Array# #-} -indexInt16Array# :: ByteArray# -> Int# -> Int16# -indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2 -{-# NOINLINE indexInt32Array# #-} -indexInt32Array# :: ByteArray# -> Int# -> Int32# -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# -> Word8# -indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2 -{-# NOINLINE indexWord16Array# #-} -indexWord16Array# :: ByteArray# -> Int# -> Word16# -indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2 -{-# NOINLINE indexWord32Array# #-} -indexWord32Array# :: ByteArray# -> Int# -> Word32# -indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2 -{-# NOINLINE indexWord64Array# #-} -indexWord64Array# :: ByteArray# -> Int# -> Word# -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 indexWord8ArrayAsInt32# #-} -indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32# -indexWord8ArrayAsInt32# a1 a2 = (GHC.Prim.indexWord8ArrayAsInt32#) a1 a2 -{-# NOINLINE indexWord8ArrayAsInt64# #-} -indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int# -indexWord8ArrayAsInt64# a1 a2 = (GHC.Prim.indexWord8ArrayAsInt64#) a1 a2 -{-# NOINLINE indexWord8ArrayAsWord16# #-} -indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16# -indexWord8ArrayAsWord16# a1 a2 = (GHC.Prim.indexWord8ArrayAsWord16#) a1 a2 -{-# NOINLINE indexWord8ArrayAsWord32# #-} -indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32# -indexWord8ArrayAsWord32# a1 a2 = (GHC.Prim.indexWord8ArrayAsWord32#) a1 a2 -{-# NOINLINE indexWord8ArrayAsWord64# #-} -indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word# -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 readInt16Array# #-} -readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #) -readInt16Array# a1 a2 a3 = (GHC.Prim.readInt16Array#) 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 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,Word8# #) -readWord8Array# a1 a2 a3 = (GHC.Prim.readWord8Array#) 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 readWord32Array# #-} -readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) -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 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 readWord8ArrayAsInt32# #-} -readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #) -readWord8ArrayAsInt32# a1 a2 a3 = (GHC.Prim.readWord8ArrayAsInt32#) a1 a2 a3 -{-# NOINLINE readWord8ArrayAsInt64# #-} -readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readWord8ArrayAsInt64# a1 a2 a3 = (GHC.Prim.readWord8ArrayAsInt64#) 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 readWord8ArrayAsWord32# #-} -readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) -readWord8ArrayAsWord32# a1 a2 a3 = (GHC.Prim.readWord8ArrayAsWord32#) a1 a2 a3 -{-# NOINLINE readWord8ArrayAsWord64# #-} -readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -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 writeInt16Array# #-} -writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s -writeInt16Array# a1 a2 a3 a4 = (GHC.Prim.writeInt16Array#) 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 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# -> Word8# -> State# s -> State# s -writeWord8Array# a1 a2 a3 a4 = (GHC.Prim.writeWord8Array#) 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 writeWord32Array# #-} -writeWord32Array# :: MutableByteArray# s -> Int# -> Word32# -> 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 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 writeWord8ArrayAsInt32# #-} -writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s -writeWord8ArrayAsInt32# a1 a2 a3 a4 = (GHC.Prim.writeWord8ArrayAsInt32#) a1 a2 a3 a4 -{-# NOINLINE writeWord8ArrayAsInt64# #-} -writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeWord8ArrayAsInt64# a1 a2 a3 a4 = (GHC.Prim.writeWord8ArrayAsInt64#) 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 writeWord8ArrayAsWord32# #-} -writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s -writeWord8ArrayAsWord32# a1 a2 a3 a4 = (GHC.Prim.writeWord8ArrayAsWord32#) a1 a2 a3 a4 -{-# NOINLINE writeWord8ArrayAsWord64# #-} -writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word# -> 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 copyByteArrayToAddr# #-} -copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s -copyByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyByteArrayToAddr#) a1 a2 a3 a4 a5 -{-# NOINLINE copyMutableByteArrayToAddr# #-} -copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s -copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyMutableByteArrayToAddr#) a1 a2 a3 a4 a5 -{-# NOINLINE copyAddrToByteArray# #-} -copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyAddrToByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.copyAddrToByteArray#) a1 a2 a3 a4 a5 -{-# NOINLINE setByteArray# #-} -setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s -setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5 -{-# NOINLINE atomicReadIntArray# #-} -atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -atomicReadIntArray# a1 a2 a3 = (GHC.Prim.atomicReadIntArray#) a1 a2 a3 -{-# NOINLINE atomicWriteIntArray# #-} -atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -atomicWriteIntArray# a1 a2 a3 a4 = (GHC.Prim.atomicWriteIntArray#) a1 a2 a3 a4 -{-# NOINLINE casIntArray# #-} -casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) -casIntArray# a1 a2 a3 a4 a5 = (GHC.Prim.casIntArray#) a1 a2 a3 a4 a5 -{-# NOINLINE fetchAddIntArray# #-} -fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAddIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAddIntArray#) a1 a2 a3 a4 -{-# NOINLINE fetchSubIntArray# #-} -fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchSubIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchSubIntArray#) a1 a2 a3 a4 -{-# NOINLINE fetchAndIntArray# #-} -fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAndIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAndIntArray#) a1 a2 a3 a4 -{-# NOINLINE fetchNandIntArray# #-} -fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchNandIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchNandIntArray#) a1 a2 a3 a4 -{-# NOINLINE fetchOrIntArray# #-} -fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchOrIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchOrIntArray#) a1 a2 a3 a4 -{-# NOINLINE fetchXorIntArray# #-} -fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchXorIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchXorIntArray#) a1 a2 a3 a4 -{-# NOINLINE newArrayArray# #-} -newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) -newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2 -{-# NOINLINE sameMutableArrayArray# #-} -sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# -sameMutableArrayArray# a1 a2 = (GHC.Prim.sameMutableArrayArray#) a1 a2 -{-# NOINLINE unsafeFreezeArrayArray# #-} -unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) -unsafeFreezeArrayArray# a1 a2 = (GHC.Prim.unsafeFreezeArrayArray#) a1 a2 -{-# NOINLINE sizeofArrayArray# #-} -sizeofArrayArray# :: ArrayArray# -> Int# -sizeofArrayArray# a1 = (GHC.Prim.sizeofArrayArray#) a1 -{-# NOINLINE sizeofMutableArrayArray# #-} -sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# -sizeofMutableArrayArray# a1 = (GHC.Prim.sizeofMutableArrayArray#) a1 -{-# NOINLINE indexByteArrayArray# #-} -indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# -indexByteArrayArray# a1 a2 = (GHC.Prim.indexByteArrayArray#) a1 a2 -{-# NOINLINE indexArrayArrayArray# #-} -indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# -indexArrayArrayArray# a1 a2 = (GHC.Prim.indexArrayArrayArray#) a1 a2 -{-# NOINLINE readByteArrayArray# #-} -readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) -readByteArrayArray# a1 a2 a3 = (GHC.Prim.readByteArrayArray#) a1 a2 a3 -{-# NOINLINE readMutableByteArrayArray# #-} -readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -readMutableByteArrayArray# a1 a2 a3 = (GHC.Prim.readMutableByteArrayArray#) a1 a2 a3 -{-# NOINLINE readArrayArrayArray# #-} -readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) -readArrayArrayArray# a1 a2 a3 = (GHC.Prim.readArrayArrayArray#) a1 a2 a3 -{-# NOINLINE readMutableArrayArrayArray# #-} -readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) -readMutableArrayArrayArray# a1 a2 a3 = (GHC.Prim.readMutableArrayArrayArray#) a1 a2 a3 -{-# NOINLINE writeByteArrayArray# #-} -writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s -writeByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeByteArrayArray#) a1 a2 a3 a4 -{-# NOINLINE writeMutableByteArrayArray# #-} -writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s -writeMutableByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableByteArrayArray#) a1 a2 a3 a4 -{-# NOINLINE writeArrayArrayArray# #-} -writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s -writeArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeArrayArrayArray#) a1 a2 a3 a4 -{-# NOINLINE writeMutableArrayArrayArray# #-} -writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s -writeMutableArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableArrayArrayArray#) a1 a2 a3 a4 -{-# NOINLINE copyArrayArray# #-} -copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArrayArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE copyMutableArrayArray# #-} -copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyMutableArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArrayArray#) a1 a2 a3 a4 a5 a6 -{-# NOINLINE plusAddr# #-} -plusAddr# :: Addr# -> Int# -> Addr# -plusAddr# a1 a2 = (GHC.Prim.plusAddr#) a1 a2 -{-# NOINLINE minusAddr# #-} -minusAddr# :: Addr# -> Addr# -> Int# -minusAddr# a1 a2 = (GHC.Prim.minusAddr#) a1 a2 -{-# NOINLINE remAddr# #-} -remAddr# :: Addr# -> Int# -> Int# -remAddr# a1 a2 = (GHC.Prim.remAddr#) a1 a2 -{-# NOINLINE addr2Int# #-} -addr2Int# :: Addr# -> Int# -addr2Int# a1 = (GHC.Prim.addr2Int#) a1 -{-# NOINLINE int2Addr# #-} -int2Addr# :: Int# -> Addr# -int2Addr# a1 = (GHC.Prim.int2Addr#) a1 -{-# NOINLINE gtAddr# #-} -gtAddr# :: Addr# -> Addr# -> Int# -gtAddr# a1 a2 = (GHC.Prim.gtAddr#) a1 a2 -{-# NOINLINE geAddr# #-} -geAddr# :: Addr# -> Addr# -> Int# -geAddr# a1 a2 = (GHC.Prim.geAddr#) a1 a2 -{-# NOINLINE eqAddr# #-} -eqAddr# :: Addr# -> Addr# -> Int# -eqAddr# a1 a2 = (GHC.Prim.eqAddr#) a1 a2 -{-# NOINLINE neAddr# #-} -neAddr# :: Addr# -> Addr# -> Int# -neAddr# a1 a2 = (GHC.Prim.neAddr#) a1 a2 -{-# NOINLINE ltAddr# #-} -ltAddr# :: Addr# -> Addr# -> Int# -ltAddr# a1 a2 = (GHC.Prim.ltAddr#) a1 a2 -{-# NOINLINE leAddr# #-} -leAddr# :: Addr# -> Addr# -> Int# -leAddr# a1 a2 = (GHC.Prim.leAddr#) a1 a2 -{-# NOINLINE indexCharOffAddr# #-} -indexCharOffAddr# :: Addr# -> Int# -> Char# -indexCharOffAddr# a1 a2 = (GHC.Prim.indexCharOffAddr#) a1 a2 -{-# NOINLINE indexWideCharOffAddr# #-} -indexWideCharOffAddr# :: Addr# -> Int# -> Char# -indexWideCharOffAddr# a1 a2 = (GHC.Prim.indexWideCharOffAddr#) a1 a2 -{-# NOINLINE indexIntOffAddr# #-} -indexIntOffAddr# :: Addr# -> Int# -> Int# -indexIntOffAddr# a1 a2 = (GHC.Prim.indexIntOffAddr#) a1 a2 -{-# NOINLINE indexWordOffAddr# #-} -indexWordOffAddr# :: Addr# -> Int# -> Word# -indexWordOffAddr# a1 a2 = (GHC.Prim.indexWordOffAddr#) a1 a2 -{-# NOINLINE indexAddrOffAddr# #-} -indexAddrOffAddr# :: Addr# -> Int# -> Addr# -indexAddrOffAddr# a1 a2 = (GHC.Prim.indexAddrOffAddr#) a1 a2 -{-# NOINLINE indexFloatOffAddr# #-} -indexFloatOffAddr# :: Addr# -> Int# -> Float# -indexFloatOffAddr# a1 a2 = (GHC.Prim.indexFloatOffAddr#) a1 a2 -{-# NOINLINE indexDoubleOffAddr# #-} -indexDoubleOffAddr# :: Addr# -> Int# -> Double# -indexDoubleOffAddr# a1 a2 = (GHC.Prim.indexDoubleOffAddr#) a1 a2 -{-# NOINLINE indexStablePtrOffAddr# #-} -indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2 -{-# NOINLINE indexInt8OffAddr# #-} -indexInt8OffAddr# :: Addr# -> Int# -> Int8# -indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2 -{-# NOINLINE indexInt16OffAddr# #-} -indexInt16OffAddr# :: Addr# -> Int# -> Int16# -indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2 -{-# NOINLINE indexInt32OffAddr# #-} -indexInt32OffAddr# :: Addr# -> Int# -> Int32# -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# -> Word8# -indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2 -{-# NOINLINE indexWord16OffAddr# #-} -indexWord16OffAddr# :: Addr# -> Int# -> Word16# -indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2 -{-# NOINLINE indexWord32OffAddr# #-} -indexWord32OffAddr# :: Addr# -> Int# -> Word32# -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,Int8# #) -readInt8OffAddr# a1 a2 a3 = (GHC.Prim.readInt8OffAddr#) a1 a2 a3 -{-# NOINLINE readInt16OffAddr# #-} -readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #) -readInt16OffAddr# a1 a2 a3 = (GHC.Prim.readInt16OffAddr#) a1 a2 a3 -{-# NOINLINE readInt32OffAddr# #-} -readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #) -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,Word8# #) -readWord8OffAddr# a1 a2 a3 = (GHC.Prim.readWord8OffAddr#) a1 a2 a3 -{-# NOINLINE readWord16OffAddr# #-} -readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #) -readWord16OffAddr# a1 a2 a3 = (GHC.Prim.readWord16OffAddr#) a1 a2 a3 -{-# NOINLINE readWord32OffAddr# #-} -readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #) -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# -> Int8# -> State# s -> State# s -writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) 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 writeInt32OffAddr# #-} -writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> 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# -> Word8# -> State# s -> State# s -writeWord8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord8OffAddr#) 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 writeWord32OffAddr# #-} -writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> 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 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 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 -> 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 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 -> 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# :: b -> o -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 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 newIOPort# #-} -newIOPort# :: State# s -> (# State# s,IOPort# s a #) -newIOPort# a1 = (GHC.Prim.newIOPort#) a1 -{-# NOINLINE readIOPort# #-} -readIOPort# :: IOPort# s a -> State# s -> (# State# s,a #) -readIOPort# a1 a2 = (GHC.Prim.readIOPort#) a1 a2 -{-# NOINLINE writeIOPort# #-} -writeIOPort# :: IOPort# s a -> a -> State# s -> (# State# s,Int# #) -writeIOPort# a1 a2 a3 = (GHC.Prim.writeIOPort#) a1 a2 a3 -{-# NOINLINE sameIOPort# #-} -sameIOPort# :: IOPort# s a -> IOPort# s a -> Int# -sameIOPort# a1 a2 = (GHC.Prim.sameIOPort#) 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# s -> State# s -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 -> (State# (RealWorld) -> (# State# (RealWorld),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),b #) #) -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 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 -> a -> 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 seq# #-} -seq# :: a -> State# s -> (# State# s,a #) -seq# a1 a2 = (GHC.Prim.seq#) 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# :: o -> State# (RealWorld) -> (State# (RealWorld) -> p) -> p -keepAlive# a1 a2 a3 = (GHC.Prim.keepAlive#) a1 a2 a3 -{-# NOINLINE dataToTag# #-} -dataToTag# :: a -> Int# -dataToTag# a1 = (GHC.Prim.dataToTag#) a1 -{-# NOINLINE addrToAny# #-} -addrToAny# :: Addr# -> (# a #) -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 -> State# s -> (# State# s,Addr# #) -whereFrom# a1 a2 = (GHC.Prim.whereFrom#) a1 a2 -{-# 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# :: Int# -> 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 +-- | Users should not import this module. It is GHC internal only. +-- Use "GHC.Exts" instead. +{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-} +{-# OPTIONS_GHC -Wno-deprecations -O0 -fno-do-eta-reduction #-} +module GHC.PrimopWrappers where +import qualified GHC.Prim +import GHC.Tuple () +import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Int64#, Word64#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, RealWorld, MutVar#, PromptTag#, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO) +{-# NOINLINE gtChar# #-} +gtChar# :: Char# -> Char# -> Int# +gtChar# a1 a2 = GHC.Prim.gtChar# a1 a2 +{-# NOINLINE geChar# #-} +geChar# :: Char# -> Char# -> Int# +geChar# a1 a2 = GHC.Prim.geChar# a1 a2 +{-# NOINLINE eqChar# #-} +eqChar# :: Char# -> Char# -> Int# +eqChar# a1 a2 = GHC.Prim.eqChar# a1 a2 +{-# NOINLINE neChar# #-} +neChar# :: Char# -> Char# -> Int# +neChar# a1 a2 = GHC.Prim.neChar# a1 a2 +{-# NOINLINE ltChar# #-} +ltChar# :: Char# -> Char# -> Int# +ltChar# a1 a2 = GHC.Prim.ltChar# a1 a2 +{-# NOINLINE leChar# #-} +leChar# :: Char# -> Char# -> Int# +leChar# a1 a2 = GHC.Prim.leChar# a1 a2 +{-# NOINLINE ord# #-} +ord# :: Char# -> Int# +ord# a1 = GHC.Prim.ord# a1 +{-# NOINLINE int8ToInt# #-} +int8ToInt# :: Int8# -> Int# +int8ToInt# a1 = GHC.Prim.int8ToInt# a1 +{-# NOINLINE intToInt8# #-} +intToInt8# :: Int# -> Int8# +intToInt8# a1 = GHC.Prim.intToInt8# a1 +{-# NOINLINE negateInt8# #-} +negateInt8# :: Int8# -> Int8# +negateInt8# a1 = GHC.Prim.negateInt8# a1 +{-# NOINLINE plusInt8# #-} +plusInt8# :: Int8# -> Int8# -> Int8# +plusInt8# a1 a2 = GHC.Prim.plusInt8# a1 a2 +{-# NOINLINE subInt8# #-} +subInt8# :: Int8# -> Int8# -> Int8# +subInt8# a1 a2 = GHC.Prim.subInt8# a1 a2 +{-# NOINLINE timesInt8# #-} +timesInt8# :: Int8# -> Int8# -> Int8# +timesInt8# a1 a2 = GHC.Prim.timesInt8# a1 a2 +{-# NOINLINE quotInt8# #-} +quotInt8# :: Int8# -> Int8# -> Int8# +quotInt8# a1 a2 = GHC.Prim.quotInt8# a1 a2 +{-# NOINLINE remInt8# #-} +remInt8# :: Int8# -> Int8# -> Int8# +remInt8# a1 a2 = GHC.Prim.remInt8# a1 a2 +{-# NOINLINE quotRemInt8# #-} +quotRemInt8# :: Int8# -> Int8# -> (# Int8#,Int8# #) +quotRemInt8# a1 a2 = GHC.Prim.quotRemInt8# a1 a2 +{-# NOINLINE uncheckedShiftLInt8# #-} +uncheckedShiftLInt8# :: Int8# -> Int# -> Int8# +uncheckedShiftLInt8# a1 a2 = GHC.Prim.uncheckedShiftLInt8# a1 a2 +{-# NOINLINE uncheckedShiftRAInt8# #-} +uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8# +uncheckedShiftRAInt8# a1 a2 = GHC.Prim.uncheckedShiftRAInt8# a1 a2 +{-# NOINLINE uncheckedShiftRLInt8# #-} +uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8# +uncheckedShiftRLInt8# a1 a2 = GHC.Prim.uncheckedShiftRLInt8# a1 a2 +{-# NOINLINE int8ToWord8# #-} +int8ToWord8# :: Int8# -> Word8# +int8ToWord8# a1 = GHC.Prim.int8ToWord8# a1 +{-# NOINLINE eqInt8# #-} +eqInt8# :: Int8# -> Int8# -> Int# +eqInt8# a1 a2 = GHC.Prim.eqInt8# a1 a2 +{-# NOINLINE geInt8# #-} +geInt8# :: Int8# -> Int8# -> Int# +geInt8# a1 a2 = GHC.Prim.geInt8# a1 a2 +{-# NOINLINE gtInt8# #-} +gtInt8# :: Int8# -> Int8# -> Int# +gtInt8# a1 a2 = GHC.Prim.gtInt8# a1 a2 +{-# NOINLINE leInt8# #-} +leInt8# :: Int8# -> Int8# -> Int# +leInt8# a1 a2 = GHC.Prim.leInt8# a1 a2 +{-# NOINLINE ltInt8# #-} +ltInt8# :: Int8# -> Int8# -> Int# +ltInt8# a1 a2 = GHC.Prim.ltInt8# a1 a2 +{-# NOINLINE neInt8# #-} +neInt8# :: Int8# -> Int8# -> Int# +neInt8# a1 a2 = GHC.Prim.neInt8# a1 a2 +{-# NOINLINE word8ToWord# #-} +word8ToWord# :: Word8# -> Word# +word8ToWord# a1 = GHC.Prim.word8ToWord# a1 +{-# NOINLINE wordToWord8# #-} +wordToWord8# :: Word# -> Word8# +wordToWord8# a1 = GHC.Prim.wordToWord8# a1 +{-# NOINLINE plusWord8# #-} +plusWord8# :: Word8# -> Word8# -> Word8# +plusWord8# a1 a2 = GHC.Prim.plusWord8# a1 a2 +{-# NOINLINE subWord8# #-} +subWord8# :: Word8# -> Word8# -> Word8# +subWord8# a1 a2 = GHC.Prim.subWord8# a1 a2 +{-# NOINLINE timesWord8# #-} +timesWord8# :: Word8# -> Word8# -> Word8# +timesWord8# a1 a2 = GHC.Prim.timesWord8# a1 a2 +{-# NOINLINE quotWord8# #-} +quotWord8# :: Word8# -> Word8# -> Word8# +quotWord8# a1 a2 = GHC.Prim.quotWord8# a1 a2 +{-# NOINLINE remWord8# #-} +remWord8# :: Word8# -> Word8# -> Word8# +remWord8# a1 a2 = GHC.Prim.remWord8# a1 a2 +{-# NOINLINE quotRemWord8# #-} +quotRemWord8# :: Word8# -> Word8# -> (# Word8#,Word8# #) +quotRemWord8# a1 a2 = GHC.Prim.quotRemWord8# a1 a2 +{-# NOINLINE andWord8# #-} +andWord8# :: Word8# -> Word8# -> Word8# +andWord8# a1 a2 = GHC.Prim.andWord8# a1 a2 +{-# NOINLINE orWord8# #-} +orWord8# :: Word8# -> Word8# -> Word8# +orWord8# a1 a2 = GHC.Prim.orWord8# a1 a2 +{-# NOINLINE xorWord8# #-} +xorWord8# :: Word8# -> Word8# -> Word8# +xorWord8# a1 a2 = GHC.Prim.xorWord8# a1 a2 +{-# NOINLINE notWord8# #-} +notWord8# :: Word8# -> Word8# +notWord8# a1 = GHC.Prim.notWord8# a1 +{-# NOINLINE uncheckedShiftLWord8# #-} +uncheckedShiftLWord8# :: Word8# -> Int# -> Word8# +uncheckedShiftLWord8# a1 a2 = GHC.Prim.uncheckedShiftLWord8# a1 a2 +{-# NOINLINE uncheckedShiftRLWord8# #-} +uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8# +uncheckedShiftRLWord8# a1 a2 = GHC.Prim.uncheckedShiftRLWord8# a1 a2 +{-# NOINLINE word8ToInt8# #-} +word8ToInt8# :: Word8# -> Int8# +word8ToInt8# a1 = GHC.Prim.word8ToInt8# a1 +{-# NOINLINE eqWord8# #-} +eqWord8# :: Word8# -> Word8# -> Int# +eqWord8# a1 a2 = GHC.Prim.eqWord8# a1 a2 +{-# NOINLINE geWord8# #-} +geWord8# :: Word8# -> Word8# -> Int# +geWord8# a1 a2 = GHC.Prim.geWord8# a1 a2 +{-# NOINLINE gtWord8# #-} +gtWord8# :: Word8# -> Word8# -> Int# +gtWord8# a1 a2 = GHC.Prim.gtWord8# a1 a2 +{-# NOINLINE leWord8# #-} +leWord8# :: Word8# -> Word8# -> Int# +leWord8# a1 a2 = GHC.Prim.leWord8# a1 a2 +{-# NOINLINE ltWord8# #-} +ltWord8# :: Word8# -> Word8# -> Int# +ltWord8# a1 a2 = GHC.Prim.ltWord8# a1 a2 +{-# NOINLINE neWord8# #-} +neWord8# :: Word8# -> Word8# -> Int# +neWord8# a1 a2 = GHC.Prim.neWord8# a1 a2 +{-# NOINLINE int16ToInt# #-} +int16ToInt# :: Int16# -> Int# +int16ToInt# a1 = GHC.Prim.int16ToInt# a1 +{-# NOINLINE intToInt16# #-} +intToInt16# :: Int# -> Int16# +intToInt16# a1 = GHC.Prim.intToInt16# a1 +{-# NOINLINE negateInt16# #-} +negateInt16# :: Int16# -> Int16# +negateInt16# a1 = GHC.Prim.negateInt16# a1 +{-# NOINLINE plusInt16# #-} +plusInt16# :: Int16# -> Int16# -> Int16# +plusInt16# a1 a2 = GHC.Prim.plusInt16# a1 a2 +{-# NOINLINE subInt16# #-} +subInt16# :: Int16# -> Int16# -> Int16# +subInt16# a1 a2 = GHC.Prim.subInt16# a1 a2 +{-# NOINLINE timesInt16# #-} +timesInt16# :: Int16# -> Int16# -> Int16# +timesInt16# a1 a2 = GHC.Prim.timesInt16# a1 a2 +{-# NOINLINE quotInt16# #-} +quotInt16# :: Int16# -> Int16# -> Int16# +quotInt16# a1 a2 = GHC.Prim.quotInt16# a1 a2 +{-# NOINLINE remInt16# #-} +remInt16# :: Int16# -> Int16# -> Int16# +remInt16# a1 a2 = GHC.Prim.remInt16# a1 a2 +{-# NOINLINE quotRemInt16# #-} +quotRemInt16# :: Int16# -> Int16# -> (# Int16#,Int16# #) +quotRemInt16# a1 a2 = GHC.Prim.quotRemInt16# a1 a2 +{-# NOINLINE uncheckedShiftLInt16# #-} +uncheckedShiftLInt16# :: Int16# -> Int# -> Int16# +uncheckedShiftLInt16# a1 a2 = GHC.Prim.uncheckedShiftLInt16# a1 a2 +{-# NOINLINE uncheckedShiftRAInt16# #-} +uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16# +uncheckedShiftRAInt16# a1 a2 = GHC.Prim.uncheckedShiftRAInt16# a1 a2 +{-# NOINLINE uncheckedShiftRLInt16# #-} +uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16# +uncheckedShiftRLInt16# a1 a2 = GHC.Prim.uncheckedShiftRLInt16# a1 a2 +{-# NOINLINE int16ToWord16# #-} +int16ToWord16# :: Int16# -> Word16# +int16ToWord16# a1 = GHC.Prim.int16ToWord16# a1 +{-# NOINLINE eqInt16# #-} +eqInt16# :: Int16# -> Int16# -> Int# +eqInt16# a1 a2 = GHC.Prim.eqInt16# a1 a2 +{-# NOINLINE geInt16# #-} +geInt16# :: Int16# -> Int16# -> Int# +geInt16# a1 a2 = GHC.Prim.geInt16# a1 a2 +{-# NOINLINE gtInt16# #-} +gtInt16# :: Int16# -> Int16# -> Int# +gtInt16# a1 a2 = GHC.Prim.gtInt16# a1 a2 +{-# NOINLINE leInt16# #-} +leInt16# :: Int16# -> Int16# -> Int# +leInt16# a1 a2 = GHC.Prim.leInt16# a1 a2 +{-# NOINLINE ltInt16# #-} +ltInt16# :: Int16# -> Int16# -> Int# +ltInt16# a1 a2 = GHC.Prim.ltInt16# a1 a2 +{-# NOINLINE neInt16# #-} +neInt16# :: Int16# -> Int16# -> Int# +neInt16# a1 a2 = GHC.Prim.neInt16# a1 a2 +{-# NOINLINE word16ToWord# #-} +word16ToWord# :: Word16# -> Word# +word16ToWord# a1 = GHC.Prim.word16ToWord# a1 +{-# NOINLINE wordToWord16# #-} +wordToWord16# :: Word# -> Word16# +wordToWord16# a1 = GHC.Prim.wordToWord16# a1 +{-# NOINLINE plusWord16# #-} +plusWord16# :: Word16# -> Word16# -> Word16# +plusWord16# a1 a2 = GHC.Prim.plusWord16# a1 a2 +{-# NOINLINE subWord16# #-} +subWord16# :: Word16# -> Word16# -> Word16# +subWord16# a1 a2 = GHC.Prim.subWord16# a1 a2 +{-# NOINLINE timesWord16# #-} +timesWord16# :: Word16# -> Word16# -> Word16# +timesWord16# a1 a2 = GHC.Prim.timesWord16# a1 a2 +{-# NOINLINE quotWord16# #-} +quotWord16# :: Word16# -> Word16# -> Word16# +quotWord16# a1 a2 = GHC.Prim.quotWord16# a1 a2 +{-# NOINLINE remWord16# #-} +remWord16# :: Word16# -> Word16# -> Word16# +remWord16# a1 a2 = GHC.Prim.remWord16# a1 a2 +{-# NOINLINE quotRemWord16# #-} +quotRemWord16# :: Word16# -> Word16# -> (# Word16#,Word16# #) +quotRemWord16# a1 a2 = GHC.Prim.quotRemWord16# a1 a2 +{-# NOINLINE andWord16# #-} +andWord16# :: Word16# -> Word16# -> Word16# +andWord16# a1 a2 = GHC.Prim.andWord16# a1 a2 +{-# NOINLINE orWord16# #-} +orWord16# :: Word16# -> Word16# -> Word16# +orWord16# a1 a2 = GHC.Prim.orWord16# a1 a2 +{-# NOINLINE xorWord16# #-} +xorWord16# :: Word16# -> Word16# -> Word16# +xorWord16# a1 a2 = GHC.Prim.xorWord16# a1 a2 +{-# NOINLINE notWord16# #-} +notWord16# :: Word16# -> Word16# +notWord16# a1 = GHC.Prim.notWord16# a1 +{-# NOINLINE uncheckedShiftLWord16# #-} +uncheckedShiftLWord16# :: Word16# -> Int# -> Word16# +uncheckedShiftLWord16# a1 a2 = GHC.Prim.uncheckedShiftLWord16# a1 a2 +{-# NOINLINE uncheckedShiftRLWord16# #-} +uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16# +uncheckedShiftRLWord16# a1 a2 = GHC.Prim.uncheckedShiftRLWord16# a1 a2 +{-# NOINLINE word16ToInt16# #-} +word16ToInt16# :: Word16# -> Int16# +word16ToInt16# a1 = GHC.Prim.word16ToInt16# a1 +{-# NOINLINE eqWord16# #-} +eqWord16# :: Word16# -> Word16# -> Int# +eqWord16# a1 a2 = GHC.Prim.eqWord16# a1 a2 +{-# NOINLINE geWord16# #-} +geWord16# :: Word16# -> Word16# -> Int# +geWord16# a1 a2 = GHC.Prim.geWord16# a1 a2 +{-# NOINLINE gtWord16# #-} +gtWord16# :: Word16# -> Word16# -> Int# +gtWord16# a1 a2 = GHC.Prim.gtWord16# a1 a2 +{-# NOINLINE leWord16# #-} +leWord16# :: Word16# -> Word16# -> Int# +leWord16# a1 a2 = GHC.Prim.leWord16# a1 a2 +{-# NOINLINE ltWord16# #-} +ltWord16# :: Word16# -> Word16# -> Int# +ltWord16# a1 a2 = GHC.Prim.ltWord16# a1 a2 +{-# NOINLINE neWord16# #-} +neWord16# :: Word16# -> Word16# -> Int# +neWord16# a1 a2 = GHC.Prim.neWord16# a1 a2 +{-# NOINLINE int32ToInt# #-} +int32ToInt# :: Int32# -> Int# +int32ToInt# a1 = GHC.Prim.int32ToInt# a1 +{-# NOINLINE intToInt32# #-} +intToInt32# :: Int# -> Int32# +intToInt32# a1 = GHC.Prim.intToInt32# a1 +{-# NOINLINE negateInt32# #-} +negateInt32# :: Int32# -> Int32# +negateInt32# a1 = GHC.Prim.negateInt32# a1 +{-# NOINLINE plusInt32# #-} +plusInt32# :: Int32# -> Int32# -> Int32# +plusInt32# a1 a2 = GHC.Prim.plusInt32# a1 a2 +{-# NOINLINE subInt32# #-} +subInt32# :: Int32# -> Int32# -> Int32# +subInt32# a1 a2 = GHC.Prim.subInt32# a1 a2 +{-# NOINLINE timesInt32# #-} +timesInt32# :: Int32# -> Int32# -> Int32# +timesInt32# a1 a2 = GHC.Prim.timesInt32# a1 a2 +{-# NOINLINE quotInt32# #-} +quotInt32# :: Int32# -> Int32# -> Int32# +quotInt32# a1 a2 = GHC.Prim.quotInt32# a1 a2 +{-# NOINLINE remInt32# #-} +remInt32# :: Int32# -> Int32# -> Int32# +remInt32# a1 a2 = GHC.Prim.remInt32# a1 a2 +{-# NOINLINE quotRemInt32# #-} +quotRemInt32# :: Int32# -> Int32# -> (# Int32#,Int32# #) +quotRemInt32# a1 a2 = GHC.Prim.quotRemInt32# a1 a2 +{-# NOINLINE uncheckedShiftLInt32# #-} +uncheckedShiftLInt32# :: Int32# -> Int# -> Int32# +uncheckedShiftLInt32# a1 a2 = GHC.Prim.uncheckedShiftLInt32# a1 a2 +{-# NOINLINE uncheckedShiftRAInt32# #-} +uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32# +uncheckedShiftRAInt32# a1 a2 = GHC.Prim.uncheckedShiftRAInt32# a1 a2 +{-# NOINLINE uncheckedShiftRLInt32# #-} +uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32# +uncheckedShiftRLInt32# a1 a2 = GHC.Prim.uncheckedShiftRLInt32# a1 a2 +{-# NOINLINE int32ToWord32# #-} +int32ToWord32# :: Int32# -> Word32# +int32ToWord32# a1 = GHC.Prim.int32ToWord32# a1 +{-# NOINLINE eqInt32# #-} +eqInt32# :: Int32# -> Int32# -> Int# +eqInt32# a1 a2 = GHC.Prim.eqInt32# a1 a2 +{-# NOINLINE geInt32# #-} +geInt32# :: Int32# -> Int32# -> Int# +geInt32# a1 a2 = GHC.Prim.geInt32# a1 a2 +{-# NOINLINE gtInt32# #-} +gtInt32# :: Int32# -> Int32# -> Int# +gtInt32# a1 a2 = GHC.Prim.gtInt32# a1 a2 +{-# NOINLINE leInt32# #-} +leInt32# :: Int32# -> Int32# -> Int# +leInt32# a1 a2 = GHC.Prim.leInt32# a1 a2 +{-# NOINLINE ltInt32# #-} +ltInt32# :: Int32# -> Int32# -> Int# +ltInt32# a1 a2 = GHC.Prim.ltInt32# a1 a2 +{-# NOINLINE neInt32# #-} +neInt32# :: Int32# -> Int32# -> Int# +neInt32# a1 a2 = GHC.Prim.neInt32# a1 a2 +{-# NOINLINE word32ToWord# #-} +word32ToWord# :: Word32# -> Word# +word32ToWord# a1 = GHC.Prim.word32ToWord# a1 +{-# NOINLINE wordToWord32# #-} +wordToWord32# :: Word# -> Word32# +wordToWord32# a1 = GHC.Prim.wordToWord32# a1 +{-# NOINLINE plusWord32# #-} +plusWord32# :: Word32# -> Word32# -> Word32# +plusWord32# a1 a2 = GHC.Prim.plusWord32# a1 a2 +{-# NOINLINE subWord32# #-} +subWord32# :: Word32# -> Word32# -> Word32# +subWord32# a1 a2 = GHC.Prim.subWord32# a1 a2 +{-# NOINLINE timesWord32# #-} +timesWord32# :: Word32# -> Word32# -> Word32# +timesWord32# a1 a2 = GHC.Prim.timesWord32# a1 a2 +{-# NOINLINE quotWord32# #-} +quotWord32# :: Word32# -> Word32# -> Word32# +quotWord32# a1 a2 = GHC.Prim.quotWord32# a1 a2 +{-# NOINLINE remWord32# #-} +remWord32# :: Word32# -> Word32# -> Word32# +remWord32# a1 a2 = GHC.Prim.remWord32# a1 a2 +{-# NOINLINE quotRemWord32# #-} +quotRemWord32# :: Word32# -> Word32# -> (# Word32#,Word32# #) +quotRemWord32# a1 a2 = GHC.Prim.quotRemWord32# a1 a2 +{-# NOINLINE andWord32# #-} +andWord32# :: Word32# -> Word32# -> Word32# +andWord32# a1 a2 = GHC.Prim.andWord32# a1 a2 +{-# NOINLINE orWord32# #-} +orWord32# :: Word32# -> Word32# -> Word32# +orWord32# a1 a2 = GHC.Prim.orWord32# a1 a2 +{-# NOINLINE xorWord32# #-} +xorWord32# :: Word32# -> Word32# -> Word32# +xorWord32# a1 a2 = GHC.Prim.xorWord32# a1 a2 +{-# NOINLINE notWord32# #-} +notWord32# :: Word32# -> Word32# +notWord32# a1 = GHC.Prim.notWord32# a1 +{-# NOINLINE uncheckedShiftLWord32# #-} +uncheckedShiftLWord32# :: Word32# -> Int# -> Word32# +uncheckedShiftLWord32# a1 a2 = GHC.Prim.uncheckedShiftLWord32# a1 a2 +{-# NOINLINE uncheckedShiftRLWord32# #-} +uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32# +uncheckedShiftRLWord32# a1 a2 = GHC.Prim.uncheckedShiftRLWord32# a1 a2 +{-# NOINLINE word32ToInt32# #-} +word32ToInt32# :: Word32# -> Int32# +word32ToInt32# a1 = GHC.Prim.word32ToInt32# a1 +{-# NOINLINE eqWord32# #-} +eqWord32# :: Word32# -> Word32# -> Int# +eqWord32# a1 a2 = GHC.Prim.eqWord32# a1 a2 +{-# NOINLINE geWord32# #-} +geWord32# :: Word32# -> Word32# -> Int# +geWord32# a1 a2 = GHC.Prim.geWord32# a1 a2 +{-# NOINLINE gtWord32# #-} +gtWord32# :: Word32# -> Word32# -> Int# +gtWord32# a1 a2 = GHC.Prim.gtWord32# a1 a2 +{-# NOINLINE leWord32# #-} +leWord32# :: Word32# -> Word32# -> Int# +leWord32# a1 a2 = GHC.Prim.leWord32# a1 a2 +{-# NOINLINE ltWord32# #-} +ltWord32# :: Word32# -> Word32# -> Int# +ltWord32# a1 a2 = GHC.Prim.ltWord32# a1 a2 +{-# NOINLINE neWord32# #-} +neWord32# :: Word32# -> Word32# -> Int# +neWord32# a1 a2 = GHC.Prim.neWord32# a1 a2 +{-# NOINLINE int64ToInt# #-} +int64ToInt# :: Int64# -> Int# +int64ToInt# a1 = GHC.Prim.int64ToInt# a1 +{-# NOINLINE intToInt64# #-} +intToInt64# :: Int# -> Int64# +intToInt64# a1 = GHC.Prim.intToInt64# a1 +{-# NOINLINE negateInt64# #-} +negateInt64# :: Int64# -> Int64# +negateInt64# a1 = GHC.Prim.negateInt64# a1 +{-# NOINLINE plusInt64# #-} +plusInt64# :: Int64# -> Int64# -> Int64# +plusInt64# a1 a2 = GHC.Prim.plusInt64# a1 a2 +{-# NOINLINE subInt64# #-} +subInt64# :: Int64# -> Int64# -> Int64# +subInt64# a1 a2 = GHC.Prim.subInt64# a1 a2 +{-# NOINLINE timesInt64# #-} +timesInt64# :: Int64# -> Int64# -> Int64# +timesInt64# a1 a2 = GHC.Prim.timesInt64# a1 a2 +{-# NOINLINE quotInt64# #-} +quotInt64# :: Int64# -> Int64# -> Int64# +quotInt64# a1 a2 = GHC.Prim.quotInt64# a1 a2 +{-# NOINLINE remInt64# #-} +remInt64# :: Int64# -> Int64# -> Int64# +remInt64# a1 a2 = GHC.Prim.remInt64# a1 a2 +{-# NOINLINE uncheckedIShiftL64# #-} +uncheckedIShiftL64# :: Int64# -> Int# -> Int64# +uncheckedIShiftL64# a1 a2 = GHC.Prim.uncheckedIShiftL64# a1 a2 +{-# NOINLINE uncheckedIShiftRA64# #-} +uncheckedIShiftRA64# :: Int64# -> Int# -> Int64# +uncheckedIShiftRA64# a1 a2 = GHC.Prim.uncheckedIShiftRA64# a1 a2 +{-# NOINLINE uncheckedIShiftRL64# #-} +uncheckedIShiftRL64# :: Int64# -> Int# -> Int64# +uncheckedIShiftRL64# a1 a2 = GHC.Prim.uncheckedIShiftRL64# a1 a2 +{-# NOINLINE int64ToWord64# #-} +int64ToWord64# :: Int64# -> Word64# +int64ToWord64# a1 = GHC.Prim.int64ToWord64# a1 +{-# NOINLINE eqInt64# #-} +eqInt64# :: Int64# -> Int64# -> Int# +eqInt64# a1 a2 = GHC.Prim.eqInt64# a1 a2 +{-# NOINLINE geInt64# #-} +geInt64# :: Int64# -> Int64# -> Int# +geInt64# a1 a2 = GHC.Prim.geInt64# a1 a2 +{-# NOINLINE gtInt64# #-} +gtInt64# :: Int64# -> Int64# -> Int# +gtInt64# a1 a2 = GHC.Prim.gtInt64# a1 a2 +{-# NOINLINE leInt64# #-} +leInt64# :: Int64# -> Int64# -> Int# +leInt64# a1 a2 = GHC.Prim.leInt64# a1 a2 +{-# NOINLINE ltInt64# #-} +ltInt64# :: Int64# -> Int64# -> Int# +ltInt64# a1 a2 = GHC.Prim.ltInt64# a1 a2 +{-# NOINLINE neInt64# #-} +neInt64# :: Int64# -> Int64# -> Int# +neInt64# a1 a2 = GHC.Prim.neInt64# a1 a2 +{-# NOINLINE word64ToWord# #-} +word64ToWord# :: Word64# -> Word# +word64ToWord# a1 = GHC.Prim.word64ToWord# a1 +{-# NOINLINE wordToWord64# #-} +wordToWord64# :: Word# -> Word64# +wordToWord64# a1 = GHC.Prim.wordToWord64# a1 +{-# NOINLINE plusWord64# #-} +plusWord64# :: Word64# -> Word64# -> Word64# +plusWord64# a1 a2 = GHC.Prim.plusWord64# a1 a2 +{-# NOINLINE subWord64# #-} +subWord64# :: Word64# -> Word64# -> Word64# +subWord64# a1 a2 = GHC.Prim.subWord64# a1 a2 +{-# NOINLINE timesWord64# #-} +timesWord64# :: Word64# -> Word64# -> Word64# +timesWord64# a1 a2 = GHC.Prim.timesWord64# a1 a2 +{-# NOINLINE quotWord64# #-} +quotWord64# :: Word64# -> Word64# -> Word64# +quotWord64# a1 a2 = GHC.Prim.quotWord64# a1 a2 +{-# NOINLINE remWord64# #-} +remWord64# :: Word64# -> Word64# -> Word64# +remWord64# a1 a2 = GHC.Prim.remWord64# a1 a2 +{-# NOINLINE and64# #-} +and64# :: Word64# -> Word64# -> Word64# +and64# a1 a2 = GHC.Prim.and64# a1 a2 +{-# NOINLINE or64# #-} +or64# :: Word64# -> Word64# -> Word64# +or64# a1 a2 = GHC.Prim.or64# a1 a2 +{-# NOINLINE xor64# #-} +xor64# :: Word64# -> Word64# -> Word64# +xor64# a1 a2 = GHC.Prim.xor64# a1 a2 +{-# NOINLINE not64# #-} +not64# :: Word64# -> Word64# +not64# a1 = GHC.Prim.not64# a1 +{-# NOINLINE uncheckedShiftL64# #-} +uncheckedShiftL64# :: Word64# -> Int# -> Word64# +uncheckedShiftL64# a1 a2 = GHC.Prim.uncheckedShiftL64# a1 a2 +{-# NOINLINE uncheckedShiftRL64# #-} +uncheckedShiftRL64# :: Word64# -> Int# -> Word64# +uncheckedShiftRL64# a1 a2 = GHC.Prim.uncheckedShiftRL64# a1 a2 +{-# NOINLINE word64ToInt64# #-} +word64ToInt64# :: Word64# -> Int64# +word64ToInt64# a1 = GHC.Prim.word64ToInt64# a1 +{-# NOINLINE eqWord64# #-} +eqWord64# :: Word64# -> Word64# -> Int# +eqWord64# a1 a2 = GHC.Prim.eqWord64# a1 a2 +{-# NOINLINE geWord64# #-} +geWord64# :: Word64# -> Word64# -> Int# +geWord64# a1 a2 = GHC.Prim.geWord64# a1 a2 +{-# NOINLINE gtWord64# #-} +gtWord64# :: Word64# -> Word64# -> Int# +gtWord64# a1 a2 = GHC.Prim.gtWord64# a1 a2 +{-# NOINLINE leWord64# #-} +leWord64# :: Word64# -> Word64# -> Int# +leWord64# a1 a2 = GHC.Prim.leWord64# a1 a2 +{-# NOINLINE ltWord64# #-} +ltWord64# :: Word64# -> Word64# -> Int# +ltWord64# a1 a2 = GHC.Prim.ltWord64# a1 a2 +{-# NOINLINE neWord64# #-} +neWord64# :: Word64# -> Word64# -> Int# +neWord64# a1 a2 = GHC.Prim.neWord64# a1 a2 +{-# NOINLINE (+#) #-} +(+#) :: Int# -> Int# -> Int# +(+#) a1 a2 = (GHC.Prim.+#) a1 a2 +{-# NOINLINE (-#) #-} +(-#) :: Int# -> Int# -> Int# +(-#) a1 a2 = (GHC.Prim.-#) a1 a2 +{-# NOINLINE (*#) #-} +(*#) :: Int# -> Int# -> Int# +(*#) a1 a2 = (GHC.Prim.*#) a1 a2 +{-# NOINLINE timesInt2# #-} +timesInt2# :: Int# -> Int# -> (# Int#,Int#,Int# #) +timesInt2# a1 a2 = GHC.Prim.timesInt2# a1 a2 +{-# NOINLINE mulIntMayOflo# #-} +mulIntMayOflo# :: Int# -> Int# -> Int# +mulIntMayOflo# a1 a2 = GHC.Prim.mulIntMayOflo# a1 a2 +{-# NOINLINE quotInt# #-} +quotInt# :: Int# -> Int# -> Int# +quotInt# a1 a2 = GHC.Prim.quotInt# a1 a2 +{-# NOINLINE remInt# #-} +remInt# :: Int# -> Int# -> Int# +remInt# a1 a2 = GHC.Prim.remInt# a1 a2 +{-# NOINLINE quotRemInt# #-} +quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) +quotRemInt# a1 a2 = GHC.Prim.quotRemInt# a1 a2 +{-# NOINLINE andI# #-} +andI# :: Int# -> Int# -> Int# +andI# a1 a2 = GHC.Prim.andI# a1 a2 +{-# NOINLINE orI# #-} +orI# :: Int# -> Int# -> Int# +orI# a1 a2 = GHC.Prim.orI# a1 a2 +{-# NOINLINE xorI# #-} +xorI# :: Int# -> Int# -> Int# +xorI# a1 a2 = GHC.Prim.xorI# a1 a2 +{-# NOINLINE notI# #-} +notI# :: Int# -> Int# +notI# a1 = GHC.Prim.notI# a1 +{-# NOINLINE negateInt# #-} +negateInt# :: Int# -> Int# +negateInt# a1 = GHC.Prim.negateInt# a1 +{-# NOINLINE addIntC# #-} +addIntC# :: Int# -> Int# -> (# Int#,Int# #) +addIntC# a1 a2 = GHC.Prim.addIntC# a1 a2 +{-# NOINLINE subIntC# #-} +subIntC# :: Int# -> Int# -> (# Int#,Int# #) +subIntC# a1 a2 = GHC.Prim.subIntC# a1 a2 +{-# NOINLINE (>#) #-} +(>#) :: Int# -> Int# -> Int# +(>#) a1 a2 = (GHC.Prim.>#) a1 a2 +{-# NOINLINE (>=#) #-} +(>=#) :: Int# -> Int# -> Int# +(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2 +{-# NOINLINE (==#) #-} +(==#) :: Int# -> Int# -> Int# +(==#) a1 a2 = (GHC.Prim.==#) a1 a2 +{-# NOINLINE (/=#) #-} +(/=#) :: Int# -> Int# -> Int# +(/=#) a1 a2 = (GHC.Prim./=#) a1 a2 +{-# NOINLINE (<#) #-} +(<#) :: Int# -> Int# -> Int# +(<#) a1 a2 = (GHC.Prim.<#) a1 a2 +{-# NOINLINE (<=#) #-} +(<=#) :: Int# -> Int# -> Int# +(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2 +{-# NOINLINE chr# #-} +chr# :: Int# -> Char# +chr# a1 = GHC.Prim.chr# a1 +{-# NOINLINE int2Word# #-} +int2Word# :: Int# -> Word# +int2Word# a1 = GHC.Prim.int2Word# a1 +{-# NOINLINE int2Float# #-} +int2Float# :: Int# -> Float# +int2Float# a1 = GHC.Prim.int2Float# a1 +{-# NOINLINE int2Double# #-} +int2Double# :: Int# -> Double# +int2Double# a1 = GHC.Prim.int2Double# a1 +{-# NOINLINE word2Float# #-} +word2Float# :: Word# -> Float# +word2Float# a1 = GHC.Prim.word2Float# a1 +{-# NOINLINE word2Double# #-} +word2Double# :: Word# -> Double# +word2Double# a1 = GHC.Prim.word2Double# a1 +{-# NOINLINE uncheckedIShiftL# #-} +uncheckedIShiftL# :: Int# -> Int# -> Int# +uncheckedIShiftL# a1 a2 = GHC.Prim.uncheckedIShiftL# a1 a2 +{-# NOINLINE uncheckedIShiftRA# #-} +uncheckedIShiftRA# :: Int# -> Int# -> Int# +uncheckedIShiftRA# a1 a2 = GHC.Prim.uncheckedIShiftRA# a1 a2 +{-# NOINLINE uncheckedIShiftRL# #-} +uncheckedIShiftRL# :: Int# -> Int# -> Int# +uncheckedIShiftRL# a1 a2 = GHC.Prim.uncheckedIShiftRL# a1 a2 +{-# NOINLINE plusWord# #-} +plusWord# :: Word# -> Word# -> Word# +plusWord# a1 a2 = GHC.Prim.plusWord# a1 a2 +{-# NOINLINE addWordC# #-} +addWordC# :: Word# -> Word# -> (# Word#,Int# #) +addWordC# a1 a2 = GHC.Prim.addWordC# a1 a2 +{-# NOINLINE subWordC# #-} +subWordC# :: Word# -> Word# -> (# Word#,Int# #) +subWordC# a1 a2 = GHC.Prim.subWordC# a1 a2 +{-# NOINLINE plusWord2# #-} +plusWord2# :: Word# -> Word# -> (# Word#,Word# #) +plusWord2# a1 a2 = GHC.Prim.plusWord2# a1 a2 +{-# NOINLINE minusWord# #-} +minusWord# :: Word# -> Word# -> Word# +minusWord# a1 a2 = GHC.Prim.minusWord# a1 a2 +{-# NOINLINE timesWord# #-} +timesWord# :: Word# -> Word# -> Word# +timesWord# a1 a2 = GHC.Prim.timesWord# a1 a2 +{-# NOINLINE timesWord2# #-} +timesWord2# :: Word# -> Word# -> (# Word#,Word# #) +timesWord2# a1 a2 = GHC.Prim.timesWord2# a1 a2 +{-# NOINLINE quotWord# #-} +quotWord# :: Word# -> Word# -> Word# +quotWord# a1 a2 = GHC.Prim.quotWord# a1 a2 +{-# NOINLINE remWord# #-} +remWord# :: Word# -> Word# -> Word# +remWord# a1 a2 = GHC.Prim.remWord# a1 a2 +{-# NOINLINE quotRemWord# #-} +quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) +quotRemWord# a1 a2 = GHC.Prim.quotRemWord# a1 a2 +{-# NOINLINE quotRemWord2# #-} +quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) +quotRemWord2# a1 a2 a3 = GHC.Prim.quotRemWord2# a1 a2 a3 +{-# NOINLINE and# #-} +and# :: Word# -> Word# -> Word# +and# a1 a2 = GHC.Prim.and# a1 a2 +{-# NOINLINE or# #-} +or# :: Word# -> Word# -> Word# +or# a1 a2 = GHC.Prim.or# a1 a2 +{-# NOINLINE xor# #-} +xor# :: Word# -> Word# -> Word# +xor# a1 a2 = GHC.Prim.xor# a1 a2 +{-# NOINLINE not# #-} +not# :: Word# -> Word# +not# a1 = GHC.Prim.not# a1 +{-# NOINLINE uncheckedShiftL# #-} +uncheckedShiftL# :: Word# -> Int# -> Word# +uncheckedShiftL# a1 a2 = GHC.Prim.uncheckedShiftL# a1 a2 +{-# NOINLINE uncheckedShiftRL# #-} +uncheckedShiftRL# :: Word# -> Int# -> Word# +uncheckedShiftRL# a1 a2 = GHC.Prim.uncheckedShiftRL# a1 a2 +{-# NOINLINE word2Int# #-} +word2Int# :: Word# -> Int# +word2Int# a1 = GHC.Prim.word2Int# a1 +{-# NOINLINE gtWord# #-} +gtWord# :: Word# -> Word# -> Int# +gtWord# a1 a2 = GHC.Prim.gtWord# a1 a2 +{-# NOINLINE geWord# #-} +geWord# :: Word# -> Word# -> Int# +geWord# a1 a2 = GHC.Prim.geWord# a1 a2 +{-# NOINLINE eqWord# #-} +eqWord# :: Word# -> Word# -> Int# +eqWord# a1 a2 = GHC.Prim.eqWord# a1 a2 +{-# NOINLINE neWord# #-} +neWord# :: Word# -> Word# -> Int# +neWord# a1 a2 = GHC.Prim.neWord# a1 a2 +{-# NOINLINE ltWord# #-} +ltWord# :: Word# -> Word# -> Int# +ltWord# a1 a2 = GHC.Prim.ltWord# a1 a2 +{-# NOINLINE leWord# #-} +leWord# :: Word# -> Word# -> Int# +leWord# a1 a2 = GHC.Prim.leWord# a1 a2 +{-# NOINLINE popCnt8# #-} +popCnt8# :: Word# -> Word# +popCnt8# a1 = GHC.Prim.popCnt8# a1 +{-# NOINLINE popCnt16# #-} +popCnt16# :: Word# -> Word# +popCnt16# a1 = GHC.Prim.popCnt16# a1 +{-# NOINLINE popCnt32# #-} +popCnt32# :: Word# -> Word# +popCnt32# a1 = GHC.Prim.popCnt32# a1 +{-# NOINLINE popCnt64# #-} +popCnt64# :: Word64# -> Word# +popCnt64# a1 = GHC.Prim.popCnt64# a1 +{-# NOINLINE popCnt# #-} +popCnt# :: Word# -> Word# +popCnt# a1 = GHC.Prim.popCnt# a1 +{-# NOINLINE pdep8# #-} +pdep8# :: Word# -> Word# -> Word# +pdep8# a1 a2 = GHC.Prim.pdep8# a1 a2 +{-# NOINLINE pdep16# #-} +pdep16# :: Word# -> Word# -> Word# +pdep16# a1 a2 = GHC.Prim.pdep16# a1 a2 +{-# NOINLINE pdep32# #-} +pdep32# :: Word# -> Word# -> Word# +pdep32# a1 a2 = GHC.Prim.pdep32# a1 a2 +{-# NOINLINE pdep64# #-} +pdep64# :: Word64# -> Word64# -> Word64# +pdep64# a1 a2 = GHC.Prim.pdep64# a1 a2 +{-# NOINLINE pdep# #-} +pdep# :: Word# -> Word# -> Word# +pdep# a1 a2 = GHC.Prim.pdep# a1 a2 +{-# NOINLINE pext8# #-} +pext8# :: Word# -> Word# -> Word# +pext8# a1 a2 = GHC.Prim.pext8# a1 a2 +{-# NOINLINE pext16# #-} +pext16# :: Word# -> Word# -> Word# +pext16# a1 a2 = GHC.Prim.pext16# a1 a2 +{-# NOINLINE pext32# #-} +pext32# :: Word# -> Word# -> Word# +pext32# a1 a2 = GHC.Prim.pext32# a1 a2 +{-# NOINLINE pext64# #-} +pext64# :: Word64# -> Word64# -> Word64# +pext64# a1 a2 = GHC.Prim.pext64# a1 a2 +{-# NOINLINE pext# #-} +pext# :: Word# -> Word# -> Word# +pext# a1 a2 = GHC.Prim.pext# a1 a2 +{-# NOINLINE clz8# #-} +clz8# :: Word# -> Word# +clz8# a1 = GHC.Prim.clz8# a1 +{-# NOINLINE clz16# #-} +clz16# :: Word# -> Word# +clz16# a1 = GHC.Prim.clz16# a1 +{-# NOINLINE clz32# #-} +clz32# :: Word# -> Word# +clz32# a1 = GHC.Prim.clz32# a1 +{-# NOINLINE clz64# #-} +clz64# :: Word64# -> Word# +clz64# a1 = GHC.Prim.clz64# a1 +{-# NOINLINE clz# #-} +clz# :: Word# -> Word# +clz# a1 = GHC.Prim.clz# a1 +{-# NOINLINE ctz8# #-} +ctz8# :: Word# -> Word# +ctz8# a1 = GHC.Prim.ctz8# a1 +{-# NOINLINE ctz16# #-} +ctz16# :: Word# -> Word# +ctz16# a1 = GHC.Prim.ctz16# a1 +{-# NOINLINE ctz32# #-} +ctz32# :: Word# -> Word# +ctz32# a1 = GHC.Prim.ctz32# a1 +{-# NOINLINE ctz64# #-} +ctz64# :: Word64# -> Word# +ctz64# a1 = GHC.Prim.ctz64# a1 +{-# NOINLINE ctz# #-} +ctz# :: Word# -> Word# +ctz# a1 = GHC.Prim.ctz# a1 +{-# NOINLINE byteSwap16# #-} +byteSwap16# :: Word# -> Word# +byteSwap16# a1 = GHC.Prim.byteSwap16# a1 +{-# NOINLINE byteSwap32# #-} +byteSwap32# :: Word# -> Word# +byteSwap32# a1 = GHC.Prim.byteSwap32# a1 +{-# NOINLINE byteSwap64# #-} +byteSwap64# :: Word64# -> Word64# +byteSwap64# a1 = GHC.Prim.byteSwap64# a1 +{-# NOINLINE byteSwap# #-} +byteSwap# :: Word# -> Word# +byteSwap# a1 = GHC.Prim.byteSwap# a1 +{-# NOINLINE bitReverse8# #-} +bitReverse8# :: Word# -> Word# +bitReverse8# a1 = GHC.Prim.bitReverse8# a1 +{-# NOINLINE bitReverse16# #-} +bitReverse16# :: Word# -> Word# +bitReverse16# a1 = GHC.Prim.bitReverse16# a1 +{-# NOINLINE bitReverse32# #-} +bitReverse32# :: Word# -> Word# +bitReverse32# a1 = GHC.Prim.bitReverse32# a1 +{-# NOINLINE bitReverse64# #-} +bitReverse64# :: Word64# -> Word64# +bitReverse64# a1 = GHC.Prim.bitReverse64# a1 +{-# NOINLINE bitReverse# #-} +bitReverse# :: Word# -> Word# +bitReverse# a1 = GHC.Prim.bitReverse# a1 +{-# NOINLINE narrow8Int# #-} +narrow8Int# :: Int# -> Int# +narrow8Int# a1 = GHC.Prim.narrow8Int# a1 +{-# NOINLINE narrow16Int# #-} +narrow16Int# :: Int# -> Int# +narrow16Int# a1 = GHC.Prim.narrow16Int# a1 +{-# NOINLINE narrow32Int# #-} +narrow32Int# :: Int# -> Int# +narrow32Int# a1 = GHC.Prim.narrow32Int# a1 +{-# NOINLINE narrow8Word# #-} +narrow8Word# :: Word# -> Word# +narrow8Word# a1 = GHC.Prim.narrow8Word# a1 +{-# NOINLINE narrow16Word# #-} +narrow16Word# :: Word# -> Word# +narrow16Word# a1 = GHC.Prim.narrow16Word# a1 +{-# NOINLINE narrow32Word# #-} +narrow32Word# :: Word# -> Word# +narrow32Word# a1 = GHC.Prim.narrow32Word# a1 +{-# NOINLINE (>##) #-} +(>##) :: Double# -> Double# -> Int# +(>##) a1 a2 = (GHC.Prim.>##) a1 a2 +{-# NOINLINE (>=##) #-} +(>=##) :: Double# -> Double# -> Int# +(>=##) a1 a2 = (GHC.Prim.>=##) a1 a2 +{-# NOINLINE (==##) #-} +(==##) :: Double# -> Double# -> Int# +(==##) a1 a2 = (GHC.Prim.==##) a1 a2 +{-# NOINLINE (/=##) #-} +(/=##) :: Double# -> Double# -> Int# +(/=##) a1 a2 = (GHC.Prim./=##) a1 a2 +{-# NOINLINE (<##) #-} +(<##) :: Double# -> Double# -> Int# +(<##) a1 a2 = (GHC.Prim.<##) a1 a2 +{-# NOINLINE (<=##) #-} +(<=##) :: Double# -> Double# -> Int# +(<=##) a1 a2 = (GHC.Prim.<=##) a1 a2 +{-# NOINLINE minDouble# #-} +minDouble# :: Double# -> Double# -> Double# +minDouble# a1 a2 = GHC.Prim.minDouble# a1 a2 +{-# NOINLINE maxDouble# #-} +maxDouble# :: Double# -> Double# -> Double# +maxDouble# a1 a2 = GHC.Prim.maxDouble# a1 a2 +{-# NOINLINE (+##) #-} +(+##) :: Double# -> Double# -> Double# +(+##) a1 a2 = (GHC.Prim.+##) a1 a2 +{-# NOINLINE (-##) #-} +(-##) :: Double# -> Double# -> Double# +(-##) a1 a2 = (GHC.Prim.-##) a1 a2 +{-# NOINLINE (*##) #-} +(*##) :: Double# -> Double# -> Double# +(*##) a1 a2 = (GHC.Prim.*##) a1 a2 +{-# NOINLINE (/##) #-} +(/##) :: Double# -> Double# -> Double# +(/##) a1 a2 = (GHC.Prim./##) a1 a2 +{-# NOINLINE negateDouble# #-} +negateDouble# :: Double# -> Double# +negateDouble# a1 = GHC.Prim.negateDouble# a1 +{-# NOINLINE fabsDouble# #-} +fabsDouble# :: Double# -> Double# +fabsDouble# a1 = GHC.Prim.fabsDouble# a1 +{-# NOINLINE double2Int# #-} +double2Int# :: Double# -> Int# +double2Int# a1 = GHC.Prim.double2Int# a1 +{-# NOINLINE double2Float# #-} +double2Float# :: Double# -> Float# +double2Float# a1 = GHC.Prim.double2Float# a1 +{-# NOINLINE expDouble# #-} +expDouble# :: Double# -> Double# +expDouble# a1 = GHC.Prim.expDouble# a1 +{-# NOINLINE expm1Double# #-} +expm1Double# :: Double# -> Double# +expm1Double# a1 = GHC.Prim.expm1Double# a1 +{-# NOINLINE logDouble# #-} +logDouble# :: Double# -> Double# +logDouble# a1 = GHC.Prim.logDouble# a1 +{-# NOINLINE log1pDouble# #-} +log1pDouble# :: Double# -> Double# +log1pDouble# a1 = GHC.Prim.log1pDouble# a1 +{-# NOINLINE sqrtDouble# #-} +sqrtDouble# :: Double# -> Double# +sqrtDouble# a1 = GHC.Prim.sqrtDouble# a1 +{-# NOINLINE sinDouble# #-} +sinDouble# :: Double# -> Double# +sinDouble# a1 = GHC.Prim.sinDouble# a1 +{-# NOINLINE cosDouble# #-} +cosDouble# :: Double# -> Double# +cosDouble# a1 = GHC.Prim.cosDouble# a1 +{-# NOINLINE tanDouble# #-} +tanDouble# :: Double# -> Double# +tanDouble# a1 = GHC.Prim.tanDouble# a1 +{-# NOINLINE asinDouble# #-} +asinDouble# :: Double# -> Double# +asinDouble# a1 = GHC.Prim.asinDouble# a1 +{-# NOINLINE acosDouble# #-} +acosDouble# :: Double# -> Double# +acosDouble# a1 = GHC.Prim.acosDouble# a1 +{-# NOINLINE atanDouble# #-} +atanDouble# :: Double# -> Double# +atanDouble# a1 = GHC.Prim.atanDouble# a1 +{-# NOINLINE sinhDouble# #-} +sinhDouble# :: Double# -> Double# +sinhDouble# a1 = GHC.Prim.sinhDouble# a1 +{-# NOINLINE coshDouble# #-} +coshDouble# :: Double# -> Double# +coshDouble# a1 = GHC.Prim.coshDouble# a1 +{-# NOINLINE tanhDouble# #-} +tanhDouble# :: Double# -> Double# +tanhDouble# a1 = GHC.Prim.tanhDouble# a1 +{-# NOINLINE asinhDouble# #-} +asinhDouble# :: Double# -> Double# +asinhDouble# a1 = GHC.Prim.asinhDouble# a1 +{-# NOINLINE acoshDouble# #-} +acoshDouble# :: Double# -> Double# +acoshDouble# a1 = GHC.Prim.acoshDouble# a1 +{-# NOINLINE atanhDouble# #-} +atanhDouble# :: Double# -> Double# +atanhDouble# a1 = GHC.Prim.atanhDouble# a1 +{-# NOINLINE (**##) #-} +(**##) :: Double# -> Double# -> Double# +(**##) a1 a2 = (GHC.Prim.**##) a1 a2 +{-# NOINLINE decodeDouble_2Int# #-} +decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) +decodeDouble_2Int# a1 = GHC.Prim.decodeDouble_2Int# a1 +{-# NOINLINE decodeDouble_Int64# #-} +decodeDouble_Int64# :: Double# -> (# Int64#,Int# #) +decodeDouble_Int64# a1 = GHC.Prim.decodeDouble_Int64# a1 +{-# NOINLINE castDoubleToWord64# #-} +castDoubleToWord64# :: Double# -> Word64# +castDoubleToWord64# a1 = GHC.Prim.castDoubleToWord64# a1 +{-# NOINLINE castWord64ToDouble# #-} +castWord64ToDouble# :: Word64# -> Double# +castWord64ToDouble# a1 = GHC.Prim.castWord64ToDouble# a1 +{-# NOINLINE gtFloat# #-} +gtFloat# :: Float# -> Float# -> Int# +gtFloat# a1 a2 = GHC.Prim.gtFloat# a1 a2 +{-# NOINLINE geFloat# #-} +geFloat# :: Float# -> Float# -> Int# +geFloat# a1 a2 = GHC.Prim.geFloat# a1 a2 +{-# NOINLINE eqFloat# #-} +eqFloat# :: Float# -> Float# -> Int# +eqFloat# a1 a2 = GHC.Prim.eqFloat# a1 a2 +{-# NOINLINE neFloat# #-} +neFloat# :: Float# -> Float# -> Int# +neFloat# a1 a2 = GHC.Prim.neFloat# a1 a2 +{-# NOINLINE ltFloat# #-} +ltFloat# :: Float# -> Float# -> Int# +ltFloat# a1 a2 = GHC.Prim.ltFloat# a1 a2 +{-# NOINLINE leFloat# #-} +leFloat# :: Float# -> Float# -> Int# +leFloat# a1 a2 = GHC.Prim.leFloat# a1 a2 +{-# NOINLINE minFloat# #-} +minFloat# :: Float# -> Float# -> Float# +minFloat# a1 a2 = GHC.Prim.minFloat# a1 a2 +{-# NOINLINE maxFloat# #-} +maxFloat# :: Float# -> Float# -> Float# +maxFloat# a1 a2 = GHC.Prim.maxFloat# a1 a2 +{-# NOINLINE plusFloat# #-} +plusFloat# :: Float# -> Float# -> Float# +plusFloat# a1 a2 = GHC.Prim.plusFloat# a1 a2 +{-# NOINLINE minusFloat# #-} +minusFloat# :: Float# -> Float# -> Float# +minusFloat# a1 a2 = GHC.Prim.minusFloat# a1 a2 +{-# NOINLINE timesFloat# #-} +timesFloat# :: Float# -> Float# -> Float# +timesFloat# a1 a2 = GHC.Prim.timesFloat# a1 a2 +{-# NOINLINE divideFloat# #-} +divideFloat# :: Float# -> Float# -> Float# +divideFloat# a1 a2 = GHC.Prim.divideFloat# a1 a2 +{-# NOINLINE negateFloat# #-} +negateFloat# :: Float# -> Float# +negateFloat# a1 = GHC.Prim.negateFloat# a1 +{-# NOINLINE fabsFloat# #-} +fabsFloat# :: Float# -> Float# +fabsFloat# a1 = GHC.Prim.fabsFloat# a1 +{-# NOINLINE float2Int# #-} +float2Int# :: Float# -> Int# +float2Int# a1 = GHC.Prim.float2Int# a1 +{-# NOINLINE expFloat# #-} +expFloat# :: Float# -> Float# +expFloat# a1 = GHC.Prim.expFloat# a1 +{-# NOINLINE expm1Float# #-} +expm1Float# :: Float# -> Float# +expm1Float# a1 = GHC.Prim.expm1Float# a1 +{-# NOINLINE logFloat# #-} +logFloat# :: Float# -> Float# +logFloat# a1 = GHC.Prim.logFloat# a1 +{-# NOINLINE log1pFloat# #-} +log1pFloat# :: Float# -> Float# +log1pFloat# a1 = GHC.Prim.log1pFloat# a1 +{-# NOINLINE sqrtFloat# #-} +sqrtFloat# :: Float# -> Float# +sqrtFloat# a1 = GHC.Prim.sqrtFloat# a1 +{-# NOINLINE sinFloat# #-} +sinFloat# :: Float# -> Float# +sinFloat# a1 = GHC.Prim.sinFloat# a1 +{-# NOINLINE cosFloat# #-} +cosFloat# :: Float# -> Float# +cosFloat# a1 = GHC.Prim.cosFloat# a1 +{-# NOINLINE tanFloat# #-} +tanFloat# :: Float# -> Float# +tanFloat# a1 = GHC.Prim.tanFloat# a1 +{-# NOINLINE asinFloat# #-} +asinFloat# :: Float# -> Float# +asinFloat# a1 = GHC.Prim.asinFloat# a1 +{-# NOINLINE acosFloat# #-} +acosFloat# :: Float# -> Float# +acosFloat# a1 = GHC.Prim.acosFloat# a1 +{-# NOINLINE atanFloat# #-} +atanFloat# :: Float# -> Float# +atanFloat# a1 = GHC.Prim.atanFloat# a1 +{-# NOINLINE sinhFloat# #-} +sinhFloat# :: Float# -> Float# +sinhFloat# a1 = GHC.Prim.sinhFloat# a1 +{-# NOINLINE coshFloat# #-} +coshFloat# :: Float# -> Float# +coshFloat# a1 = GHC.Prim.coshFloat# a1 +{-# NOINLINE tanhFloat# #-} +tanhFloat# :: Float# -> Float# +tanhFloat# a1 = GHC.Prim.tanhFloat# a1 +{-# NOINLINE asinhFloat# #-} +asinhFloat# :: Float# -> Float# +asinhFloat# a1 = GHC.Prim.asinhFloat# a1 +{-# NOINLINE acoshFloat# #-} +acoshFloat# :: Float# -> Float# +acoshFloat# a1 = GHC.Prim.acoshFloat# a1 +{-# NOINLINE atanhFloat# #-} +atanhFloat# :: Float# -> Float# +atanhFloat# a1 = GHC.Prim.atanhFloat# a1 +{-# NOINLINE powerFloat# #-} +powerFloat# :: Float# -> Float# -> Float# +powerFloat# a1 a2 = GHC.Prim.powerFloat# a1 a2 +{-# NOINLINE float2Double# #-} +float2Double# :: Float# -> Double# +float2Double# a1 = GHC.Prim.float2Double# a1 +{-# NOINLINE decodeFloat_Int# #-} +decodeFloat_Int# :: Float# -> (# Int#,Int# #) +decodeFloat_Int# a1 = GHC.Prim.decodeFloat_Int# a1 +{-# NOINLINE castFloatToWord32# #-} +castFloatToWord32# :: Float# -> Word32# +castFloatToWord32# a1 = GHC.Prim.castFloatToWord32# a1 +{-# NOINLINE castWord32ToFloat# #-} +castWord32ToFloat# :: Word32# -> Float# +castWord32ToFloat# a1 = GHC.Prim.castWord32ToFloat# a1 +{-# NOINLINE fmaddFloat# #-} +fmaddFloat# :: Float# -> Float# -> Float# -> Float# +fmaddFloat# a1 a2 a3 = GHC.Prim.fmaddFloat# a1 a2 a3 +{-# NOINLINE fmsubFloat# #-} +fmsubFloat# :: Float# -> Float# -> Float# -> Float# +fmsubFloat# a1 a2 a3 = GHC.Prim.fmsubFloat# a1 a2 a3 +{-# NOINLINE fnmaddFloat# #-} +fnmaddFloat# :: Float# -> Float# -> Float# -> Float# +fnmaddFloat# a1 a2 a3 = GHC.Prim.fnmaddFloat# a1 a2 a3 +{-# NOINLINE fnmsubFloat# #-} +fnmsubFloat# :: Float# -> Float# -> Float# -> Float# +fnmsubFloat# a1 a2 a3 = GHC.Prim.fnmsubFloat# a1 a2 a3 +{-# NOINLINE fmaddDouble# #-} +fmaddDouble# :: Double# -> Double# -> Double# -> Double# +fmaddDouble# a1 a2 a3 = GHC.Prim.fmaddDouble# a1 a2 a3 +{-# NOINLINE fmsubDouble# #-} +fmsubDouble# :: Double# -> Double# -> Double# -> Double# +fmsubDouble# a1 a2 a3 = GHC.Prim.fmsubDouble# a1 a2 a3 +{-# NOINLINE fnmaddDouble# #-} +fnmaddDouble# :: Double# -> Double# -> Double# -> Double# +fnmaddDouble# a1 a2 a3 = GHC.Prim.fnmaddDouble# a1 a2 a3 +{-# NOINLINE fnmsubDouble# #-} +fnmsubDouble# :: Double# -> Double# -> Double# -> Double# +fnmsubDouble# a1 a2 a3 = GHC.Prim.fnmsubDouble# a1 a2 a3 +{-# NOINLINE newArray# #-} +newArray# :: Int# -> a_levpoly -> State# s -> (# State# s,MutableArray# s a_levpoly #) +newArray# a1 a2 a3 = GHC.Prim.newArray# a1 a2 a3 +{-# NOINLINE readArray# #-} +readArray# :: MutableArray# s a_levpoly -> Int# -> State# s -> (# State# s,a_levpoly #) +readArray# a1 a2 a3 = GHC.Prim.readArray# a1 a2 a3 +{-# NOINLINE writeArray# #-} +writeArray# :: MutableArray# s a_levpoly -> Int# -> a_levpoly -> State# s -> State# s +writeArray# a1 a2 a3 a4 = GHC.Prim.writeArray# a1 a2 a3 a4 +{-# NOINLINE sizeofArray# #-} +sizeofArray# :: Array# a_levpoly -> Int# +sizeofArray# a1 = GHC.Prim.sizeofArray# a1 +{-# NOINLINE sizeofMutableArray# #-} +sizeofMutableArray# :: MutableArray# s a_levpoly -> Int# +sizeofMutableArray# a1 = GHC.Prim.sizeofMutableArray# a1 +{-# NOINLINE indexArray# #-} +indexArray# :: Array# a_levpoly -> Int# -> (# a_levpoly #) +indexArray# a1 a2 = GHC.Prim.indexArray# a1 a2 +{-# NOINLINE unsafeFreezeArray# #-} +unsafeFreezeArray# :: MutableArray# s a_levpoly -> State# s -> (# State# s,Array# a_levpoly #) +unsafeFreezeArray# a1 a2 = GHC.Prim.unsafeFreezeArray# a1 a2 +{-# NOINLINE unsafeThawArray# #-} +unsafeThawArray# :: Array# a_levpoly -> State# s -> (# State# s,MutableArray# s a_levpoly #) +unsafeThawArray# a1 a2 = GHC.Prim.unsafeThawArray# a1 a2 +{-# NOINLINE copyArray# #-} +copyArray# :: Array# a_levpoly -> Int# -> MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s +copyArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE copyMutableArray# #-} +copyMutableArray# :: MutableArray# s a_levpoly -> Int# -> MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s +copyMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE cloneArray# #-} +cloneArray# :: Array# a_levpoly -> Int# -> Int# -> Array# a_levpoly +cloneArray# a1 a2 a3 = GHC.Prim.cloneArray# a1 a2 a3 +{-# NOINLINE cloneMutableArray# #-} +cloneMutableArray# :: MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a_levpoly #) +cloneMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneMutableArray# a1 a2 a3 a4 +{-# NOINLINE freezeArray# #-} +freezeArray# :: MutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,Array# a_levpoly #) +freezeArray# a1 a2 a3 a4 = GHC.Prim.freezeArray# a1 a2 a3 a4 +{-# NOINLINE thawArray# #-} +thawArray# :: Array# a_levpoly -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a_levpoly #) +thawArray# a1 a2 a3 a4 = GHC.Prim.thawArray# a1 a2 a3 a4 +{-# NOINLINE casArray# #-} +casArray# :: MutableArray# s a_levpoly -> Int# -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #) +casArray# a1 a2 a3 a4 a5 = GHC.Prim.casArray# a1 a2 a3 a4 a5 +{-# NOINLINE newSmallArray# #-} +newSmallArray# :: Int# -> a_levpoly -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #) +newSmallArray# a1 a2 a3 = GHC.Prim.newSmallArray# a1 a2 a3 +{-# NOINLINE shrinkSmallMutableArray# #-} +shrinkSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> State# s -> State# s +shrinkSmallMutableArray# a1 a2 a3 = GHC.Prim.shrinkSmallMutableArray# a1 a2 a3 +{-# NOINLINE readSmallArray# #-} +readSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> State# s -> (# State# s,a_levpoly #) +readSmallArray# a1 a2 a3 = GHC.Prim.readSmallArray# a1 a2 a3 +{-# NOINLINE writeSmallArray# #-} +writeSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> a_levpoly -> State# s -> State# s +writeSmallArray# a1 a2 a3 a4 = GHC.Prim.writeSmallArray# a1 a2 a3 a4 +{-# NOINLINE sizeofSmallArray# #-} +sizeofSmallArray# :: SmallArray# a_levpoly -> Int# +sizeofSmallArray# a1 = GHC.Prim.sizeofSmallArray# a1 +{-# NOINLINE sizeofSmallMutableArray# #-} +sizeofSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# +sizeofSmallMutableArray# a1 = GHC.Prim.sizeofSmallMutableArray# a1 +{-# NOINLINE getSizeofSmallMutableArray# #-} +getSizeofSmallMutableArray# :: SmallMutableArray# s a_levpoly -> State# s -> (# State# s,Int# #) +getSizeofSmallMutableArray# a1 a2 = GHC.Prim.getSizeofSmallMutableArray# a1 a2 +{-# NOINLINE indexSmallArray# #-} +indexSmallArray# :: SmallArray# a_levpoly -> Int# -> (# a_levpoly #) +indexSmallArray# a1 a2 = GHC.Prim.indexSmallArray# a1 a2 +{-# NOINLINE unsafeFreezeSmallArray# #-} +unsafeFreezeSmallArray# :: SmallMutableArray# s a_levpoly -> State# s -> (# State# s,SmallArray# a_levpoly #) +unsafeFreezeSmallArray# a1 a2 = GHC.Prim.unsafeFreezeSmallArray# a1 a2 +{-# NOINLINE unsafeThawSmallArray# #-} +unsafeThawSmallArray# :: SmallArray# a_levpoly -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #) +unsafeThawSmallArray# a1 a2 = GHC.Prim.unsafeThawSmallArray# a1 a2 +{-# NOINLINE copySmallArray# #-} +copySmallArray# :: SmallArray# a_levpoly -> Int# -> SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s +copySmallArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE copySmallMutableArray# #-} +copySmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> State# s +copySmallMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallMutableArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE cloneSmallArray# #-} +cloneSmallArray# :: SmallArray# a_levpoly -> Int# -> Int# -> SmallArray# a_levpoly +cloneSmallArray# a1 a2 a3 = GHC.Prim.cloneSmallArray# a1 a2 a3 +{-# NOINLINE cloneSmallMutableArray# #-} +cloneSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #) +cloneSmallMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneSmallMutableArray# a1 a2 a3 a4 +{-# NOINLINE freezeSmallArray# #-} +freezeSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a_levpoly #) +freezeSmallArray# a1 a2 a3 a4 = GHC.Prim.freezeSmallArray# a1 a2 a3 a4 +{-# NOINLINE thawSmallArray# #-} +thawSmallArray# :: SmallArray# a_levpoly -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a_levpoly #) +thawSmallArray# a1 a2 a3 a4 = GHC.Prim.thawSmallArray# a1 a2 a3 a4 +{-# NOINLINE casSmallArray# #-} +casSmallArray# :: SmallMutableArray# s a_levpoly -> Int# -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #) +casSmallArray# a1 a2 a3 a4 a5 = GHC.Prim.casSmallArray# a1 a2 a3 a4 a5 +{-# NOINLINE newByteArray# #-} +newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newByteArray# a1 a2 = GHC.Prim.newByteArray# a1 a2 +{-# NOINLINE newPinnedByteArray# #-} +newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newPinnedByteArray# a1 a2 = GHC.Prim.newPinnedByteArray# a1 a2 +{-# NOINLINE newAlignedPinnedByteArray# #-} +newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +newAlignedPinnedByteArray# a1 a2 a3 = GHC.Prim.newAlignedPinnedByteArray# a1 a2 a3 +{-# NOINLINE isMutableByteArrayPinned# #-} +isMutableByteArrayPinned# :: MutableByteArray# s -> Int# +isMutableByteArrayPinned# a1 = GHC.Prim.isMutableByteArrayPinned# a1 +{-# NOINLINE isByteArrayPinned# #-} +isByteArrayPinned# :: ByteArray# -> Int# +isByteArrayPinned# a1 = GHC.Prim.isByteArrayPinned# a1 +{-# NOINLINE isByteArrayWeaklyPinned# #-} +isByteArrayWeaklyPinned# :: ByteArray# -> Int# +isByteArrayWeaklyPinned# a1 = GHC.Prim.isByteArrayWeaklyPinned# a1 +{-# NOINLINE isMutableByteArrayWeaklyPinned# #-} +isMutableByteArrayWeaklyPinned# :: MutableByteArray# s -> Int# +isMutableByteArrayWeaklyPinned# a1 = GHC.Prim.isMutableByteArrayWeaklyPinned# a1 +{-# NOINLINE byteArrayContents# #-} +byteArrayContents# :: ByteArray# -> Addr# +byteArrayContents# a1 = GHC.Prim.byteArrayContents# a1 +{-# NOINLINE mutableByteArrayContents# #-} +mutableByteArrayContents# :: MutableByteArray# s -> Addr# +mutableByteArrayContents# a1 = GHC.Prim.mutableByteArrayContents# a1 +{-# NOINLINE shrinkMutableByteArray# #-} +shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s +shrinkMutableByteArray# a1 a2 a3 = GHC.Prim.shrinkMutableByteArray# a1 a2 a3 +{-# NOINLINE resizeMutableByteArray# #-} +resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +resizeMutableByteArray# a1 a2 a3 = GHC.Prim.resizeMutableByteArray# a1 a2 a3 +{-# NOINLINE unsafeFreezeByteArray# #-} +unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) +unsafeFreezeByteArray# a1 a2 = GHC.Prim.unsafeFreezeByteArray# a1 a2 +{-# NOINLINE unsafeThawByteArray# #-} +unsafeThawByteArray# :: ByteArray# -> State# s -> (# State# s,MutableByteArray# s #) +unsafeThawByteArray# a1 a2 = GHC.Prim.unsafeThawByteArray# a1 a2 +{-# NOINLINE sizeofByteArray# #-} +sizeofByteArray# :: ByteArray# -> Int# +sizeofByteArray# a1 = GHC.Prim.sizeofByteArray# a1 +{-# NOINLINE sizeofMutableByteArray# #-} +sizeofMutableByteArray# :: MutableByteArray# s -> Int# +sizeofMutableByteArray# a1 = GHC.Prim.sizeofMutableByteArray# a1 +{-# NOINLINE getSizeofMutableByteArray# #-} +getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #) +getSizeofMutableByteArray# a1 a2 = GHC.Prim.getSizeofMutableByteArray# a1 a2 +{-# NOINLINE indexCharArray# #-} +indexCharArray# :: ByteArray# -> Int# -> Char# +indexCharArray# a1 a2 = GHC.Prim.indexCharArray# a1 a2 +{-# NOINLINE indexWideCharArray# #-} +indexWideCharArray# :: ByteArray# -> Int# -> Char# +indexWideCharArray# a1 a2 = GHC.Prim.indexWideCharArray# a1 a2 +{-# NOINLINE indexIntArray# #-} +indexIntArray# :: ByteArray# -> Int# -> Int# +indexIntArray# a1 a2 = GHC.Prim.indexIntArray# a1 a2 +{-# NOINLINE indexWordArray# #-} +indexWordArray# :: ByteArray# -> Int# -> Word# +indexWordArray# a1 a2 = GHC.Prim.indexWordArray# a1 a2 +{-# NOINLINE indexAddrArray# #-} +indexAddrArray# :: ByteArray# -> Int# -> Addr# +indexAddrArray# a1 a2 = GHC.Prim.indexAddrArray# a1 a2 +{-# NOINLINE indexFloatArray# #-} +indexFloatArray# :: ByteArray# -> Int# -> Float# +indexFloatArray# a1 a2 = GHC.Prim.indexFloatArray# a1 a2 +{-# NOINLINE indexDoubleArray# #-} +indexDoubleArray# :: ByteArray# -> Int# -> Double# +indexDoubleArray# a1 a2 = GHC.Prim.indexDoubleArray# a1 a2 +{-# NOINLINE indexStablePtrArray# #-} +indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a +indexStablePtrArray# a1 a2 = GHC.Prim.indexStablePtrArray# a1 a2 +{-# NOINLINE indexInt8Array# #-} +indexInt8Array# :: ByteArray# -> Int# -> Int8# +indexInt8Array# a1 a2 = GHC.Prim.indexInt8Array# a1 a2 +{-# NOINLINE indexWord8Array# #-} +indexWord8Array# :: ByteArray# -> Int# -> Word8# +indexWord8Array# a1 a2 = GHC.Prim.indexWord8Array# a1 a2 +{-# NOINLINE indexInt16Array# #-} +indexInt16Array# :: ByteArray# -> Int# -> Int16# +indexInt16Array# a1 a2 = GHC.Prim.indexInt16Array# a1 a2 +{-# NOINLINE indexWord16Array# #-} +indexWord16Array# :: ByteArray# -> Int# -> Word16# +indexWord16Array# a1 a2 = GHC.Prim.indexWord16Array# a1 a2 +{-# NOINLINE indexInt32Array# #-} +indexInt32Array# :: ByteArray# -> Int# -> Int32# +indexInt32Array# a1 a2 = GHC.Prim.indexInt32Array# a1 a2 +{-# NOINLINE indexWord32Array# #-} +indexWord32Array# :: ByteArray# -> Int# -> Word32# +indexWord32Array# a1 a2 = GHC.Prim.indexWord32Array# a1 a2 +{-# NOINLINE indexInt64Array# #-} +indexInt64Array# :: ByteArray# -> Int# -> Int64# +indexInt64Array# a1 a2 = GHC.Prim.indexInt64Array# a1 a2 +{-# NOINLINE indexWord64Array# #-} +indexWord64Array# :: ByteArray# -> Int# -> Word64# +indexWord64Array# a1 a2 = GHC.Prim.indexWord64Array# a1 a2 +{-# NOINLINE indexWord8ArrayAsChar# #-} +indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char# +indexWord8ArrayAsChar# a1 a2 = GHC.Prim.indexWord8ArrayAsChar# a1 a2 +{-# NOINLINE indexWord8ArrayAsWideChar# #-} +indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char# +indexWord8ArrayAsWideChar# a1 a2 = GHC.Prim.indexWord8ArrayAsWideChar# a1 a2 +{-# NOINLINE indexWord8ArrayAsInt# #-} +indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int# +indexWord8ArrayAsInt# a1 a2 = GHC.Prim.indexWord8ArrayAsInt# a1 a2 +{-# NOINLINE indexWord8ArrayAsWord# #-} +indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word# +indexWord8ArrayAsWord# a1 a2 = GHC.Prim.indexWord8ArrayAsWord# a1 a2 +{-# NOINLINE indexWord8ArrayAsAddr# #-} +indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr# +indexWord8ArrayAsAddr# a1 a2 = GHC.Prim.indexWord8ArrayAsAddr# a1 a2 +{-# NOINLINE indexWord8ArrayAsFloat# #-} +indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float# +indexWord8ArrayAsFloat# a1 a2 = GHC.Prim.indexWord8ArrayAsFloat# a1 a2 +{-# NOINLINE indexWord8ArrayAsDouble# #-} +indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double# +indexWord8ArrayAsDouble# a1 a2 = GHC.Prim.indexWord8ArrayAsDouble# a1 a2 +{-# NOINLINE indexWord8ArrayAsStablePtr# #-} +indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a +indexWord8ArrayAsStablePtr# a1 a2 = GHC.Prim.indexWord8ArrayAsStablePtr# a1 a2 +{-# NOINLINE indexWord8ArrayAsInt16# #-} +indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16# +indexWord8ArrayAsInt16# a1 a2 = GHC.Prim.indexWord8ArrayAsInt16# a1 a2 +{-# NOINLINE indexWord8ArrayAsWord16# #-} +indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16# +indexWord8ArrayAsWord16# a1 a2 = GHC.Prim.indexWord8ArrayAsWord16# a1 a2 +{-# NOINLINE indexWord8ArrayAsInt32# #-} +indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32# +indexWord8ArrayAsInt32# a1 a2 = GHC.Prim.indexWord8ArrayAsInt32# a1 a2 +{-# NOINLINE indexWord8ArrayAsWord32# #-} +indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32# +indexWord8ArrayAsWord32# a1 a2 = GHC.Prim.indexWord8ArrayAsWord32# a1 a2 +{-# NOINLINE indexWord8ArrayAsInt64# #-} +indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64# +indexWord8ArrayAsInt64# a1 a2 = GHC.Prim.indexWord8ArrayAsInt64# a1 a2 +{-# NOINLINE indexWord8ArrayAsWord64# #-} +indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64# +indexWord8ArrayAsWord64# a1 a2 = GHC.Prim.indexWord8ArrayAsWord64# a1 a2 +{-# NOINLINE readCharArray# #-} +readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readCharArray# a1 a2 a3 = GHC.Prim.readCharArray# a1 a2 a3 +{-# NOINLINE readWideCharArray# #-} +readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWideCharArray# a1 a2 a3 = GHC.Prim.readWideCharArray# a1 a2 a3 +{-# NOINLINE readIntArray# #-} +readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readIntArray# a1 a2 a3 = GHC.Prim.readIntArray# a1 a2 a3 +{-# NOINLINE readWordArray# #-} +readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWordArray# a1 a2 a3 = GHC.Prim.readWordArray# a1 a2 a3 +{-# NOINLINE readAddrArray# #-} +readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) +readAddrArray# a1 a2 a3 = GHC.Prim.readAddrArray# a1 a2 a3 +{-# NOINLINE readFloatArray# #-} +readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) +readFloatArray# a1 a2 a3 = GHC.Prim.readFloatArray# a1 a2 a3 +{-# NOINLINE readDoubleArray# #-} +readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) +readDoubleArray# a1 a2 a3 = GHC.Prim.readDoubleArray# a1 a2 a3 +{-# NOINLINE readStablePtrArray# #-} +readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrArray# a1 a2 a3 = GHC.Prim.readStablePtrArray# a1 a2 a3 +{-# NOINLINE readInt8Array# #-} +readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8# #) +readInt8Array# a1 a2 a3 = GHC.Prim.readInt8Array# a1 a2 a3 +{-# NOINLINE readWord8Array# #-} +readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8# #) +readWord8Array# a1 a2 a3 = GHC.Prim.readWord8Array# a1 a2 a3 +{-# NOINLINE readInt16Array# #-} +readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #) +readInt16Array# a1 a2 a3 = GHC.Prim.readInt16Array# a1 a2 a3 +{-# NOINLINE readWord16Array# #-} +readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #) +readWord16Array# a1 a2 a3 = GHC.Prim.readWord16Array# a1 a2 a3 +{-# NOINLINE readInt32Array# #-} +readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #) +readInt32Array# a1 a2 a3 = GHC.Prim.readInt32Array# a1 a2 a3 +{-# NOINLINE readWord32Array# #-} +readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) +readWord32Array# a1 a2 a3 = GHC.Prim.readWord32Array# a1 a2 a3 +{-# NOINLINE readInt64Array# #-} +readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #) +readInt64Array# a1 a2 a3 = GHC.Prim.readInt64Array# a1 a2 a3 +{-# NOINLINE readWord64Array# #-} +readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #) +readWord64Array# a1 a2 a3 = GHC.Prim.readWord64Array# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsChar# #-} +readWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWord8ArrayAsChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsChar# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsWideChar# #-} +readWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWord8ArrayAsWideChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWideChar# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsInt# #-} +readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readWord8ArrayAsInt# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsWord# #-} +readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord8ArrayAsWord# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsAddr# #-} +readWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) +readWord8ArrayAsAddr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsAddr# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsFloat# #-} +readWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) +readWord8ArrayAsFloat# a1 a2 a3 = GHC.Prim.readWord8ArrayAsFloat# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsDouble# #-} +readWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) +readWord8ArrayAsDouble# a1 a2 a3 = GHC.Prim.readWord8ArrayAsDouble# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsStablePtr# #-} +readWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) +readWord8ArrayAsStablePtr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsStablePtr# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsInt16# #-} +readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #) +readWord8ArrayAsInt16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt16# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsWord16# #-} +readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #) +readWord8ArrayAsWord16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord16# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsInt32# #-} +readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #) +readWord8ArrayAsInt32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt32# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsWord32# #-} +readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) +readWord8ArrayAsWord32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord32# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsInt64# #-} +readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #) +readWord8ArrayAsInt64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt64# a1 a2 a3 +{-# NOINLINE readWord8ArrayAsWord64# #-} +readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #) +readWord8ArrayAsWord64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord64# a1 a2 a3 +{-# NOINLINE writeCharArray# #-} +writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeCharArray# a1 a2 a3 a4 = GHC.Prim.writeCharArray# a1 a2 a3 a4 +{-# NOINLINE writeWideCharArray# #-} +writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWideCharArray# a1 a2 a3 a4 = GHC.Prim.writeWideCharArray# a1 a2 a3 a4 +{-# NOINLINE writeIntArray# #-} +writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeIntArray# a1 a2 a3 a4 = GHC.Prim.writeIntArray# a1 a2 a3 a4 +{-# NOINLINE writeWordArray# #-} +writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWordArray# a1 a2 a3 a4 = GHC.Prim.writeWordArray# a1 a2 a3 a4 +{-# NOINLINE writeAddrArray# #-} +writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s +writeAddrArray# a1 a2 a3 a4 = GHC.Prim.writeAddrArray# a1 a2 a3 a4 +{-# NOINLINE writeFloatArray# #-} +writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s +writeFloatArray# a1 a2 a3 a4 = GHC.Prim.writeFloatArray# a1 a2 a3 a4 +{-# NOINLINE writeDoubleArray# #-} +writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s +writeDoubleArray# a1 a2 a3 a4 = GHC.Prim.writeDoubleArray# a1 a2 a3 a4 +{-# NOINLINE writeStablePtrArray# #-} +writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrArray# a1 a2 a3 a4 = GHC.Prim.writeStablePtrArray# a1 a2 a3 a4 +{-# NOINLINE writeInt8Array# #-} +writeInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> State# s -> State# s +writeInt8Array# a1 a2 a3 a4 = GHC.Prim.writeInt8Array# a1 a2 a3 a4 +{-# NOINLINE writeWord8Array# #-} +writeWord8Array# :: MutableByteArray# s -> Int# -> Word8# -> State# s -> State# s +writeWord8Array# a1 a2 a3 a4 = GHC.Prim.writeWord8Array# a1 a2 a3 a4 +{-# NOINLINE writeInt16Array# #-} +writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s +writeInt16Array# a1 a2 a3 a4 = GHC.Prim.writeInt16Array# a1 a2 a3 a4 +{-# NOINLINE writeWord16Array# #-} +writeWord16Array# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s +writeWord16Array# a1 a2 a3 a4 = GHC.Prim.writeWord16Array# a1 a2 a3 a4 +{-# NOINLINE writeInt32Array# #-} +writeInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s +writeInt32Array# a1 a2 a3 a4 = GHC.Prim.writeInt32Array# a1 a2 a3 a4 +{-# NOINLINE writeWord32Array# #-} +writeWord32Array# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s +writeWord32Array# a1 a2 a3 a4 = GHC.Prim.writeWord32Array# a1 a2 a3 a4 +{-# NOINLINE writeInt64Array# #-} +writeInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s +writeInt64Array# a1 a2 a3 a4 = GHC.Prim.writeInt64Array# a1 a2 a3 a4 +{-# NOINLINE writeWord64Array# #-} +writeWord64Array# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s +writeWord64Array# a1 a2 a3 a4 = GHC.Prim.writeWord64Array# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsChar# #-} +writeWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWord8ArrayAsChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsChar# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsWideChar# #-} +writeWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWord8ArrayAsWideChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWideChar# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsInt# #-} +writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeWord8ArrayAsInt# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsWord# #-} +writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord8ArrayAsWord# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsAddr# #-} +writeWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s +writeWord8ArrayAsAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsFloat# #-} +writeWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s +writeWord8ArrayAsFloat# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsFloat# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsDouble# #-} +writeWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s +writeWord8ArrayAsDouble# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsDouble# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsStablePtr# #-} +writeWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s +writeWord8ArrayAsStablePtr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsStablePtr# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsInt16# #-} +writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s +writeWord8ArrayAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt16# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsWord16# #-} +writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s +writeWord8ArrayAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord16# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsInt32# #-} +writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s +writeWord8ArrayAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt32# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsWord32# #-} +writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s +writeWord8ArrayAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord32# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsInt64# #-} +writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s +writeWord8ArrayAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt64# a1 a2 a3 a4 +{-# NOINLINE writeWord8ArrayAsWord64# #-} +writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s +writeWord8ArrayAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord64# a1 a2 a3 a4 +{-# NOINLINE compareByteArrays# #-} +compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int# +compareByteArrays# a1 a2 a3 a4 a5 = GHC.Prim.compareByteArrays# a1 a2 a3 a4 a5 +{-# NOINLINE copyByteArray# #-} +copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyByteArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyByteArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE copyMutableByteArray# #-} +copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableByteArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArray# a1 a2 a3 a4 a5 a6 +{-# NOINLINE copyMutableByteArrayNonOverlapping# #-} +copyMutableByteArrayNonOverlapping# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6 +{-# NOINLINE copyByteArrayToAddr# #-} +copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s +copyByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyByteArrayToAddr# a1 a2 a3 a4 a5 +{-# NOINLINE copyMutableByteArrayToAddr# #-} +copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s +copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 +{-# NOINLINE copyAddrToByteArray# #-} +copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyAddrToByteArray# a1 a2 a3 a4 a5 = GHC.Prim.copyAddrToByteArray# a1 a2 a3 a4 a5 +{-# NOINLINE copyAddrToAddr# #-} +copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld) +copyAddrToAddr# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddr# a1 a2 a3 a4 +{-# NOINLINE copyAddrToAddrNonOverlapping# #-} +copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld) +copyAddrToAddrNonOverlapping# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddrNonOverlapping# a1 a2 a3 a4 +{-# NOINLINE setByteArray# #-} +setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s +setByteArray# a1 a2 a3 a4 a5 = GHC.Prim.setByteArray# a1 a2 a3 a4 a5 +{-# NOINLINE setAddrRange# #-} +setAddrRange# :: Addr# -> Int# -> Int# -> State# (RealWorld) -> State# (RealWorld) +setAddrRange# a1 a2 a3 a4 = GHC.Prim.setAddrRange# a1 a2 a3 a4 +{-# NOINLINE atomicReadIntArray# #-} +atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +atomicReadIntArray# a1 a2 a3 = GHC.Prim.atomicReadIntArray# a1 a2 a3 +{-# NOINLINE atomicWriteIntArray# #-} +atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +atomicWriteIntArray# a1 a2 a3 a4 = GHC.Prim.atomicWriteIntArray# a1 a2 a3 a4 +{-# NOINLINE casIntArray# #-} +casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) +casIntArray# a1 a2 a3 a4 a5 = GHC.Prim.casIntArray# a1 a2 a3 a4 a5 +{-# NOINLINE casInt8Array# #-} +casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s,Int8# #) +casInt8Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt8Array# a1 a2 a3 a4 a5 +{-# NOINLINE casInt16Array# #-} +casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s,Int16# #) +casInt16Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt16Array# a1 a2 a3 a4 a5 +{-# NOINLINE casInt32Array# #-} +casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s,Int32# #) +casInt32Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt32Array# a1 a2 a3 a4 a5 +{-# NOINLINE casInt64Array# #-} +casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s,Int64# #) +casInt64Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt64Array# a1 a2 a3 a4 a5 +{-# NOINLINE fetchAddIntArray# #-} +fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAddIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAddIntArray# a1 a2 a3 a4 +{-# NOINLINE fetchSubIntArray# #-} +fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchSubIntArray# a1 a2 a3 a4 = GHC.Prim.fetchSubIntArray# a1 a2 a3 a4 +{-# NOINLINE fetchAndIntArray# #-} +fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAndIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAndIntArray# a1 a2 a3 a4 +{-# NOINLINE fetchNandIntArray# #-} +fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchNandIntArray# a1 a2 a3 a4 = GHC.Prim.fetchNandIntArray# a1 a2 a3 a4 +{-# NOINLINE fetchOrIntArray# #-} +fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchOrIntArray# a1 a2 a3 a4 = GHC.Prim.fetchOrIntArray# a1 a2 a3 a4 +{-# NOINLINE fetchXorIntArray# #-} +fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchXorIntArray# a1 a2 a3 a4 = GHC.Prim.fetchXorIntArray# a1 a2 a3 a4 +{-# NOINLINE plusAddr# #-} +plusAddr# :: Addr# -> Int# -> Addr# +plusAddr# a1 a2 = GHC.Prim.plusAddr# a1 a2 +{-# NOINLINE minusAddr# #-} +minusAddr# :: Addr# -> Addr# -> Int# +minusAddr# a1 a2 = GHC.Prim.minusAddr# a1 a2 +{-# NOINLINE remAddr# #-} +remAddr# :: Addr# -> Int# -> Int# +remAddr# a1 a2 = GHC.Prim.remAddr# a1 a2 +{-# NOINLINE addr2Int# #-} +addr2Int# :: Addr# -> Int# +addr2Int# a1 = GHC.Prim.addr2Int# a1 +{-# NOINLINE int2Addr# #-} +int2Addr# :: Int# -> Addr# +int2Addr# a1 = GHC.Prim.int2Addr# a1 +{-# NOINLINE gtAddr# #-} +gtAddr# :: Addr# -> Addr# -> Int# +gtAddr# a1 a2 = GHC.Prim.gtAddr# a1 a2 +{-# NOINLINE geAddr# #-} +geAddr# :: Addr# -> Addr# -> Int# +geAddr# a1 a2 = GHC.Prim.geAddr# a1 a2 +{-# NOINLINE eqAddr# #-} +eqAddr# :: Addr# -> Addr# -> Int# +eqAddr# a1 a2 = GHC.Prim.eqAddr# a1 a2 +{-# NOINLINE neAddr# #-} +neAddr# :: Addr# -> Addr# -> Int# +neAddr# a1 a2 = GHC.Prim.neAddr# a1 a2 +{-# NOINLINE ltAddr# #-} +ltAddr# :: Addr# -> Addr# -> Int# +ltAddr# a1 a2 = GHC.Prim.ltAddr# a1 a2 +{-# NOINLINE leAddr# #-} +leAddr# :: Addr# -> Addr# -> Int# +leAddr# a1 a2 = GHC.Prim.leAddr# a1 a2 +{-# NOINLINE indexCharOffAddr# #-} +indexCharOffAddr# :: Addr# -> Int# -> Char# +indexCharOffAddr# a1 a2 = GHC.Prim.indexCharOffAddr# a1 a2 +{-# NOINLINE indexWideCharOffAddr# #-} +indexWideCharOffAddr# :: Addr# -> Int# -> Char# +indexWideCharOffAddr# a1 a2 = GHC.Prim.indexWideCharOffAddr# a1 a2 +{-# NOINLINE indexIntOffAddr# #-} +indexIntOffAddr# :: Addr# -> Int# -> Int# +indexIntOffAddr# a1 a2 = GHC.Prim.indexIntOffAddr# a1 a2 +{-# NOINLINE indexWordOffAddr# #-} +indexWordOffAddr# :: Addr# -> Int# -> Word# +indexWordOffAddr# a1 a2 = GHC.Prim.indexWordOffAddr# a1 a2 +{-# NOINLINE indexAddrOffAddr# #-} +indexAddrOffAddr# :: Addr# -> Int# -> Addr# +indexAddrOffAddr# a1 a2 = GHC.Prim.indexAddrOffAddr# a1 a2 +{-# NOINLINE indexFloatOffAddr# #-} +indexFloatOffAddr# :: Addr# -> Int# -> Float# +indexFloatOffAddr# a1 a2 = GHC.Prim.indexFloatOffAddr# a1 a2 +{-# NOINLINE indexDoubleOffAddr# #-} +indexDoubleOffAddr# :: Addr# -> Int# -> Double# +indexDoubleOffAddr# a1 a2 = GHC.Prim.indexDoubleOffAddr# a1 a2 +{-# NOINLINE indexStablePtrOffAddr# #-} +indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a +indexStablePtrOffAddr# a1 a2 = GHC.Prim.indexStablePtrOffAddr# a1 a2 +{-# NOINLINE indexInt8OffAddr# #-} +indexInt8OffAddr# :: Addr# -> Int# -> Int8# +indexInt8OffAddr# a1 a2 = GHC.Prim.indexInt8OffAddr# a1 a2 +{-# NOINLINE indexWord8OffAddr# #-} +indexWord8OffAddr# :: Addr# -> Int# -> Word8# +indexWord8OffAddr# a1 a2 = GHC.Prim.indexWord8OffAddr# a1 a2 +{-# NOINLINE indexInt16OffAddr# #-} +indexInt16OffAddr# :: Addr# -> Int# -> Int16# +indexInt16OffAddr# a1 a2 = GHC.Prim.indexInt16OffAddr# a1 a2 +{-# NOINLINE indexWord16OffAddr# #-} +indexWord16OffAddr# :: Addr# -> Int# -> Word16# +indexWord16OffAddr# a1 a2 = GHC.Prim.indexWord16OffAddr# a1 a2 +{-# NOINLINE indexInt32OffAddr# #-} +indexInt32OffAddr# :: Addr# -> Int# -> Int32# +indexInt32OffAddr# a1 a2 = GHC.Prim.indexInt32OffAddr# a1 a2 +{-# NOINLINE indexWord32OffAddr# #-} +indexWord32OffAddr# :: Addr# -> Int# -> Word32# +indexWord32OffAddr# a1 a2 = GHC.Prim.indexWord32OffAddr# a1 a2 +{-# NOINLINE indexInt64OffAddr# #-} +indexInt64OffAddr# :: Addr# -> Int# -> Int64# +indexInt64OffAddr# a1 a2 = GHC.Prim.indexInt64OffAddr# a1 a2 +{-# NOINLINE indexWord64OffAddr# #-} +indexWord64OffAddr# :: Addr# -> Int# -> Word64# +indexWord64OffAddr# a1 a2 = GHC.Prim.indexWord64OffAddr# a1 a2 +{-# NOINLINE indexWord8OffAddrAsChar# #-} +indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char# +indexWord8OffAddrAsChar# a1 a2 = GHC.Prim.indexWord8OffAddrAsChar# a1 a2 +{-# NOINLINE indexWord8OffAddrAsWideChar# #-} +indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# +indexWord8OffAddrAsWideChar# a1 a2 = GHC.Prim.indexWord8OffAddrAsWideChar# a1 a2 +{-# NOINLINE indexWord8OffAddrAsInt# #-} +indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int# +indexWord8OffAddrAsInt# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt# a1 a2 +{-# NOINLINE indexWord8OffAddrAsWord# #-} +indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word# +indexWord8OffAddrAsWord# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord# a1 a2 +{-# NOINLINE indexWord8OffAddrAsAddr# #-} +indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# +indexWord8OffAddrAsAddr# a1 a2 = GHC.Prim.indexWord8OffAddrAsAddr# a1 a2 +{-# NOINLINE indexWord8OffAddrAsFloat# #-} +indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# +indexWord8OffAddrAsFloat# a1 a2 = GHC.Prim.indexWord8OffAddrAsFloat# a1 a2 +{-# NOINLINE indexWord8OffAddrAsDouble# #-} +indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# +indexWord8OffAddrAsDouble# a1 a2 = GHC.Prim.indexWord8OffAddrAsDouble# a1 a2 +{-# NOINLINE indexWord8OffAddrAsStablePtr# #-} +indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a +indexWord8OffAddrAsStablePtr# a1 a2 = GHC.Prim.indexWord8OffAddrAsStablePtr# a1 a2 +{-# NOINLINE indexWord8OffAddrAsInt16# #-} +indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# +indexWord8OffAddrAsInt16# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt16# a1 a2 +{-# NOINLINE indexWord8OffAddrAsWord16# #-} +indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# +indexWord8OffAddrAsWord16# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord16# a1 a2 +{-# NOINLINE indexWord8OffAddrAsInt32# #-} +indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# +indexWord8OffAddrAsInt32# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt32# a1 a2 +{-# NOINLINE indexWord8OffAddrAsWord32# #-} +indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# +indexWord8OffAddrAsWord32# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord32# a1 a2 +{-# NOINLINE indexWord8OffAddrAsInt64# #-} +indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# +indexWord8OffAddrAsInt64# a1 a2 = GHC.Prim.indexWord8OffAddrAsInt64# a1 a2 +{-# NOINLINE indexWord8OffAddrAsWord64# #-} +indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# +indexWord8OffAddrAsWord64# a1 a2 = GHC.Prim.indexWord8OffAddrAsWord64# a1 a2 +{-# NOINLINE readCharOffAddr# #-} +readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readCharOffAddr# a1 a2 a3 = GHC.Prim.readCharOffAddr# a1 a2 a3 +{-# NOINLINE readWideCharOffAddr# #-} +readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWideCharOffAddr# a1 a2 a3 = GHC.Prim.readWideCharOffAddr# a1 a2 a3 +{-# NOINLINE readIntOffAddr# #-} +readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readIntOffAddr# a1 a2 a3 = GHC.Prim.readIntOffAddr# a1 a2 a3 +{-# NOINLINE readWordOffAddr# #-} +readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWordOffAddr# a1 a2 a3 = GHC.Prim.readWordOffAddr# a1 a2 a3 +{-# NOINLINE readAddrOffAddr# #-} +readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) +readAddrOffAddr# a1 a2 a3 = GHC.Prim.readAddrOffAddr# a1 a2 a3 +{-# NOINLINE readFloatOffAddr# #-} +readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) +readFloatOffAddr# a1 a2 a3 = GHC.Prim.readFloatOffAddr# a1 a2 a3 +{-# NOINLINE readDoubleOffAddr# #-} +readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) +readDoubleOffAddr# a1 a2 a3 = GHC.Prim.readDoubleOffAddr# a1 a2 a3 +{-# NOINLINE readStablePtrOffAddr# #-} +readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrOffAddr# a1 a2 a3 = GHC.Prim.readStablePtrOffAddr# a1 a2 a3 +{-# NOINLINE readInt8OffAddr# #-} +readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8# #) +readInt8OffAddr# a1 a2 a3 = GHC.Prim.readInt8OffAddr# a1 a2 a3 +{-# NOINLINE readWord8OffAddr# #-} +readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8# #) +readWord8OffAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddr# a1 a2 a3 +{-# NOINLINE readInt16OffAddr# #-} +readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #) +readInt16OffAddr# a1 a2 a3 = GHC.Prim.readInt16OffAddr# a1 a2 a3 +{-# NOINLINE readWord16OffAddr# #-} +readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #) +readWord16OffAddr# a1 a2 a3 = GHC.Prim.readWord16OffAddr# a1 a2 a3 +{-# NOINLINE readInt32OffAddr# #-} +readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #) +readInt32OffAddr# a1 a2 a3 = GHC.Prim.readInt32OffAddr# a1 a2 a3 +{-# NOINLINE readWord32OffAddr# #-} +readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #) +readWord32OffAddr# a1 a2 a3 = GHC.Prim.readWord32OffAddr# a1 a2 a3 +{-# NOINLINE readInt64OffAddr# #-} +readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #) +readInt64OffAddr# a1 a2 a3 = GHC.Prim.readInt64OffAddr# a1 a2 a3 +{-# NOINLINE readWord64OffAddr# #-} +readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #) +readWord64OffAddr# a1 a2 a3 = GHC.Prim.readWord64OffAddr# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsChar# #-} +readWord8OffAddrAsChar# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWord8OffAddrAsChar# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsChar# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsWideChar# #-} +readWord8OffAddrAsWideChar# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWord8OffAddrAsWideChar# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWideChar# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsInt# #-} +readWord8OffAddrAsInt# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readWord8OffAddrAsInt# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsWord# #-} +readWord8OffAddrAsWord# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord8OffAddrAsWord# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsAddr# #-} +readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) +readWord8OffAddrAsAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsAddr# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsFloat# #-} +readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) +readWord8OffAddrAsFloat# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsFloat# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsDouble# #-} +readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) +readWord8OffAddrAsDouble# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsDouble# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsStablePtr# #-} +readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) +readWord8OffAddrAsStablePtr# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsStablePtr# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsInt16# #-} +readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #) +readWord8OffAddrAsInt16# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt16# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsWord16# #-} +readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #) +readWord8OffAddrAsWord16# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord16# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsInt32# #-} +readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #) +readWord8OffAddrAsInt32# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt32# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsWord32# #-} +readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #) +readWord8OffAddrAsWord32# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord32# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsInt64# #-} +readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #) +readWord8OffAddrAsInt64# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsInt64# a1 a2 a3 +{-# NOINLINE readWord8OffAddrAsWord64# #-} +readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #) +readWord8OffAddrAsWord64# a1 a2 a3 = GHC.Prim.readWord8OffAddrAsWord64# a1 a2 a3 +{-# NOINLINE writeCharOffAddr# #-} +writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeCharOffAddr# a1 a2 a3 a4 = GHC.Prim.writeCharOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWideCharOffAddr# #-} +writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWideCharOffAddr# a1 a2 a3 a4 = GHC.Prim.writeWideCharOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeIntOffAddr# #-} +writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeIntOffAddr# a1 a2 a3 a4 = GHC.Prim.writeIntOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWordOffAddr# #-} +writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWordOffAddr# a1 a2 a3 a4 = GHC.Prim.writeWordOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeAddrOffAddr# #-} +writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s +writeAddrOffAddr# a1 a2 a3 a4 = GHC.Prim.writeAddrOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeFloatOffAddr# #-} +writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s +writeFloatOffAddr# a1 a2 a3 a4 = GHC.Prim.writeFloatOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeDoubleOffAddr# #-} +writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s +writeDoubleOffAddr# a1 a2 a3 a4 = GHC.Prim.writeDoubleOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeStablePtrOffAddr# #-} +writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrOffAddr# a1 a2 a3 a4 = GHC.Prim.writeStablePtrOffAddr# a1 a2 a3 a4 +{-# NOINLINE writeInt8OffAddr# #-} +writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# s -> State# s +writeInt8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt8OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddr# #-} +writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# s -> State# s +writeWord8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeInt16OffAddr# #-} +writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s +writeInt16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt16OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord16OffAddr# #-} +writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# s -> State# s +writeWord16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord16OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeInt32OffAddr# #-} +writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# s -> State# s +writeInt32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt32OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord32OffAddr# #-} +writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# s -> State# s +writeWord32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord32OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeInt64OffAddr# #-} +writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# s -> State# s +writeInt64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt64OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord64OffAddr# #-} +writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# s -> State# s +writeWord64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord64OffAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsChar# #-} +writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWord8OffAddrAsChar# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsChar# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsWideChar# #-} +writeWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWord8OffAddrAsWideChar# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWideChar# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsInt# #-} +writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeWord8OffAddrAsInt# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsWord# #-} +writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord8OffAddrAsWord# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsAddr# #-} +writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s +writeWord8OffAddrAsAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsAddr# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsFloat# #-} +writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# s -> State# s +writeWord8OffAddrAsFloat# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsFloat# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsDouble# #-} +writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# s -> State# s +writeWord8OffAddrAsDouble# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsDouble# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsStablePtr# #-} +writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s +writeWord8OffAddrAsStablePtr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsStablePtr# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsInt16# #-} +writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# s -> State# s +writeWord8OffAddrAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt16# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsWord16# #-} +writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# s -> State# s +writeWord8OffAddrAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord16# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsInt32# #-} +writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# s -> State# s +writeWord8OffAddrAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt32# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsWord32# #-} +writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# s -> State# s +writeWord8OffAddrAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord32# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsInt64# #-} +writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# s -> State# s +writeWord8OffAddrAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsInt64# a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddrAsWord64# #-} +writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# s -> State# s +writeWord8OffAddrAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddrAsWord64# a1 a2 a3 a4 +{-# NOINLINE atomicExchangeAddrAddr# #-} +atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s,Addr# #) +atomicExchangeAddrAddr# a1 a2 a3 = GHC.Prim.atomicExchangeAddrAddr# a1 a2 a3 +{-# NOINLINE atomicExchangeWordAddr# #-} +atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +atomicExchangeWordAddr# a1 a2 a3 = GHC.Prim.atomicExchangeWordAddr# a1 a2 a3 +{-# NOINLINE atomicCasAddrAddr# #-} +atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s,Addr# #) +atomicCasAddrAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasAddrAddr# a1 a2 a3 a4 +{-# NOINLINE atomicCasWordAddr# #-} +atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s,Word# #) +atomicCasWordAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasWordAddr# a1 a2 a3 a4 +{-# NOINLINE atomicCasWord8Addr# #-} +atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s,Word8# #) +atomicCasWord8Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord8Addr# a1 a2 a3 a4 +{-# NOINLINE atomicCasWord16Addr# #-} +atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s,Word16# #) +atomicCasWord16Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord16Addr# a1 a2 a3 a4 +{-# NOINLINE atomicCasWord32Addr# #-} +atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s,Word32# #) +atomicCasWord32Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord32Addr# a1 a2 a3 a4 +{-# NOINLINE atomicCasWord64Addr# #-} +atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# s -> (# State# s,Word64# #) +atomicCasWord64Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord64Addr# a1 a2 a3 a4 +{-# NOINLINE fetchAddWordAddr# #-} +fetchAddWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchAddWordAddr# a1 a2 a3 = GHC.Prim.fetchAddWordAddr# a1 a2 a3 +{-# NOINLINE fetchSubWordAddr# #-} +fetchSubWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchSubWordAddr# a1 a2 a3 = GHC.Prim.fetchSubWordAddr# a1 a2 a3 +{-# NOINLINE fetchAndWordAddr# #-} +fetchAndWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchAndWordAddr# a1 a2 a3 = GHC.Prim.fetchAndWordAddr# a1 a2 a3 +{-# NOINLINE fetchNandWordAddr# #-} +fetchNandWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchNandWordAddr# a1 a2 a3 = GHC.Prim.fetchNandWordAddr# a1 a2 a3 +{-# NOINLINE fetchOrWordAddr# #-} +fetchOrWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchOrWordAddr# a1 a2 a3 = GHC.Prim.fetchOrWordAddr# a1 a2 a3 +{-# NOINLINE fetchXorWordAddr# #-} +fetchXorWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +fetchXorWordAddr# a1 a2 a3 = GHC.Prim.fetchXorWordAddr# a1 a2 a3 +{-# NOINLINE atomicReadWordAddr# #-} +atomicReadWordAddr# :: Addr# -> State# s -> (# State# s,Word# #) +atomicReadWordAddr# a1 a2 = GHC.Prim.atomicReadWordAddr# a1 a2 +{-# NOINLINE atomicWriteWordAddr# #-} +atomicWriteWordAddr# :: Addr# -> Word# -> State# s -> State# s +atomicWriteWordAddr# a1 a2 a3 = GHC.Prim.atomicWriteWordAddr# a1 a2 a3 +{-# NOINLINE newMutVar# #-} +newMutVar# :: a_levpoly -> State# s -> (# State# s,MutVar# s a_levpoly #) +newMutVar# a1 a2 = GHC.Prim.newMutVar# a1 a2 +{-# NOINLINE readMutVar# #-} +readMutVar# :: MutVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +readMutVar# a1 a2 = GHC.Prim.readMutVar# a1 a2 +{-# NOINLINE writeMutVar# #-} +writeMutVar# :: MutVar# s a_levpoly -> a_levpoly -> State# s -> State# s +writeMutVar# a1 a2 a3 = GHC.Prim.writeMutVar# a1 a2 a3 +{-# NOINLINE atomicSwapMutVar# #-} +atomicSwapMutVar# :: MutVar# s a_levpoly -> a_levpoly -> State# s -> (# State# s,a_levpoly #) +atomicSwapMutVar# a1 a2 a3 = GHC.Prim.atomicSwapMutVar# a1 a2 a3 +{-# NOINLINE atomicModifyMutVar2# #-} +atomicModifyMutVar2# :: MutVar# s a -> (a -> c) -> State# s -> (# State# s,a,c #) +atomicModifyMutVar2# a1 a2 a3 = GHC.Prim.atomicModifyMutVar2# a1 a2 a3 +{-# NOINLINE atomicModifyMutVar_# #-} +atomicModifyMutVar_# :: MutVar# s a -> (a -> a) -> State# s -> (# State# s,a,a #) +atomicModifyMutVar_# a1 a2 a3 = GHC.Prim.atomicModifyMutVar_# a1 a2 a3 +{-# NOINLINE casMutVar# #-} +casMutVar# :: MutVar# s a_levpoly -> a_levpoly -> a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #) +casMutVar# a1 a2 a3 a4 = GHC.Prim.casMutVar# a1 a2 a3 a4 +{-# NOINLINE catch# #-} +catch# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> (b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #) +catch# a1 a2 a3 = GHC.Prim.catch# a1 a2 a3 +{-# NOINLINE raise# #-} +raise# :: a_levpoly -> b_reppoly +raise# a1 = GHC.Prim.raise# a1 +{-# NOINLINE raiseUnderflow# #-} +raiseUnderflow# :: (# #) -> b_reppoly +raiseUnderflow# a1 = GHC.Prim.raiseUnderflow# a1 +{-# NOINLINE raiseOverflow# #-} +raiseOverflow# :: (# #) -> b_reppoly +raiseOverflow# a1 = GHC.Prim.raiseOverflow# a1 +{-# NOINLINE raiseDivZero# #-} +raiseDivZero# :: (# #) -> b_reppoly +raiseDivZero# a1 = GHC.Prim.raiseDivZero# a1 +{-# NOINLINE raiseIO# #-} +raiseIO# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),b_reppoly #) +raiseIO# a1 a2 = GHC.Prim.raiseIO# a1 a2 +{-# NOINLINE maskAsyncExceptions# #-} +maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #) +maskAsyncExceptions# a1 a2 = GHC.Prim.maskAsyncExceptions# a1 a2 +{-# NOINLINE maskUninterruptible# #-} +maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #) +maskUninterruptible# a1 a2 = GHC.Prim.maskUninterruptible# a1 a2 +{-# NOINLINE unmaskAsyncExceptions# #-} +unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_reppoly #) +unmaskAsyncExceptions# a1 a2 = GHC.Prim.unmaskAsyncExceptions# a1 a2 +{-# NOINLINE getMaskingState# #-} +getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +getMaskingState# a1 = GHC.Prim.getMaskingState# a1 +{-# NOINLINE newPromptTag# #-} +newPromptTag# :: State# (RealWorld) -> (# State# (RealWorld),PromptTag# a #) +newPromptTag# a1 = GHC.Prim.newPromptTag# a1 +{-# NOINLINE prompt# #-} +prompt# :: PromptTag# a -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +prompt# a1 a2 a3 = GHC.Prim.prompt# a1 a2 a3 +{-# NOINLINE control0# #-} +control0# :: PromptTag# a -> (((State# (RealWorld) -> (# State# (RealWorld),b_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),b_reppoly #) +control0# a1 a2 a3 = GHC.Prim.control0# a1 a2 a3 +{-# NOINLINE atomically# #-} +atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #) +atomically# a1 a2 = GHC.Prim.atomically# a1 a2 +{-# NOINLINE retry# #-} +retry# :: State# (RealWorld) -> (# State# (RealWorld),a_levpoly #) +retry# a1 = GHC.Prim.retry# a1 +{-# NOINLINE catchRetry# #-} +catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #) +catchRetry# a1 a2 a3 = GHC.Prim.catchRetry# a1 a2 a3 +{-# NOINLINE catchSTM# #-} +catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #)) -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #) +catchSTM# a1 a2 a3 = GHC.Prim.catchSTM# a1 a2 a3 +{-# NOINLINE newTVar# #-} +newTVar# :: a_levpoly -> State# s -> (# State# s,TVar# s a_levpoly #) +newTVar# a1 a2 = GHC.Prim.newTVar# a1 a2 +{-# NOINLINE readTVar# #-} +readTVar# :: TVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +readTVar# a1 a2 = GHC.Prim.readTVar# a1 a2 +{-# NOINLINE readTVarIO# #-} +readTVarIO# :: TVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +readTVarIO# a1 a2 = GHC.Prim.readTVarIO# a1 a2 +{-# NOINLINE writeTVar# #-} +writeTVar# :: TVar# s a_levpoly -> a_levpoly -> State# s -> State# s +writeTVar# a1 a2 a3 = GHC.Prim.writeTVar# a1 a2 a3 +{-# NOINLINE newMVar# #-} +newMVar# :: State# s -> (# State# s,MVar# s a_levpoly #) +newMVar# a1 = GHC.Prim.newMVar# a1 +{-# NOINLINE takeMVar# #-} +takeMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +takeMVar# a1 a2 = GHC.Prim.takeMVar# a1 a2 +{-# NOINLINE tryTakeMVar# #-} +tryTakeMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #) +tryTakeMVar# a1 a2 = GHC.Prim.tryTakeMVar# a1 a2 +{-# NOINLINE putMVar# #-} +putMVar# :: MVar# s a_levpoly -> a_levpoly -> State# s -> State# s +putMVar# a1 a2 a3 = GHC.Prim.putMVar# a1 a2 a3 +{-# NOINLINE tryPutMVar# #-} +tryPutMVar# :: MVar# s a_levpoly -> a_levpoly -> State# s -> (# State# s,Int# #) +tryPutMVar# a1 a2 a3 = GHC.Prim.tryPutMVar# a1 a2 a3 +{-# NOINLINE readMVar# #-} +readMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +readMVar# a1 a2 = GHC.Prim.readMVar# a1 a2 +{-# NOINLINE tryReadMVar# #-} +tryReadMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int#,a_levpoly #) +tryReadMVar# a1 a2 = GHC.Prim.tryReadMVar# a1 a2 +{-# NOINLINE isEmptyMVar# #-} +isEmptyMVar# :: MVar# s a_levpoly -> State# s -> (# State# s,Int# #) +isEmptyMVar# a1 a2 = GHC.Prim.isEmptyMVar# a1 a2 +{-# NOINLINE newIOPort# #-} +newIOPort# :: State# s -> (# State# s,IOPort# s a_levpoly #) +newIOPort# a1 = GHC.Prim.newIOPort# a1 +{-# NOINLINE readIOPort# #-} +readIOPort# :: IOPort# s a_levpoly -> State# s -> (# State# s,a_levpoly #) +readIOPort# a1 a2 = GHC.Prim.readIOPort# a1 a2 +{-# NOINLINE writeIOPort# #-} +writeIOPort# :: IOPort# s a_levpoly -> a_levpoly -> State# s -> (# State# s,Int# #) +writeIOPort# a1 a2 a3 = GHC.Prim.writeIOPort# a1 a2 a3 +{-# NOINLINE delay# #-} +delay# :: Int# -> State# s -> State# s +delay# a1 a2 = GHC.Prim.delay# a1 a2 +{-# NOINLINE waitRead# #-} +waitRead# :: Int# -> State# s -> State# s +waitRead# a1 a2 = GHC.Prim.waitRead# a1 a2 +{-# NOINLINE waitWrite# #-} +waitWrite# :: Int# -> State# s -> State# s +waitWrite# a1 a2 = GHC.Prim.waitWrite# a1 a2 +{-# NOINLINE fork# #-} +fork# :: (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +fork# a1 a2 = GHC.Prim.fork# a1 a2 +{-# NOINLINE forkOn# #-} +forkOn# :: Int# -> (State# (RealWorld) -> (# State# (RealWorld),a_reppoly #)) -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +forkOn# a1 a2 a3 = GHC.Prim.forkOn# a1 a2 a3 +{-# NOINLINE killThread# #-} +killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) +killThread# a1 a2 a3 = GHC.Prim.killThread# a1 a2 a3 +{-# NOINLINE yield# #-} +yield# :: State# (RealWorld) -> State# (RealWorld) +yield# a1 = GHC.Prim.yield# a1 +{-# NOINLINE myThreadId# #-} +myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +myThreadId# a1 = GHC.Prim.myThreadId# a1 +{-# NOINLINE labelThread# #-} +labelThread# :: ThreadId# -> ByteArray# -> State# (RealWorld) -> State# (RealWorld) +labelThread# a1 a2 a3 = GHC.Prim.labelThread# a1 a2 a3 +{-# NOINLINE isCurrentThreadBound# #-} +isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +isCurrentThreadBound# a1 = GHC.Prim.isCurrentThreadBound# a1 +{-# NOINLINE noDuplicate# #-} +noDuplicate# :: State# s -> State# s +noDuplicate# a1 = GHC.Prim.noDuplicate# a1 +{-# NOINLINE threadLabel# #-} +threadLabel# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,ByteArray# #) +threadLabel# a1 a2 = GHC.Prim.threadLabel# a1 a2 +{-# NOINLINE threadStatus# #-} +threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) +threadStatus# a1 a2 = GHC.Prim.threadStatus# a1 a2 +{-# NOINLINE listThreads# #-} +listThreads# :: State# (RealWorld) -> (# State# (RealWorld),Array# (ThreadId#) #) +listThreads# a1 = GHC.Prim.listThreads# a1 +{-# NOINLINE mkWeak# #-} +mkWeak# :: a_levpoly -> b_levpoly -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b_levpoly #) +mkWeak# a1 a2 a3 a4 = GHC.Prim.mkWeak# a1 a2 a3 a4 +{-# NOINLINE mkWeakNoFinalizer# #-} +mkWeakNoFinalizer# :: a_levpoly -> b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Weak# b_levpoly #) +mkWeakNoFinalizer# a1 a2 a3 = GHC.Prim.mkWeakNoFinalizer# a1 a2 a3 +{-# NOINLINE addCFinalizerToWeak# #-} +addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int# #) +addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = GHC.Prim.addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 +{-# NOINLINE deRefWeak# #-} +deRefWeak# :: Weak# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int#,a_levpoly #) +deRefWeak# a1 a2 = GHC.Prim.deRefWeak# a1 a2 +{-# NOINLINE finalizeWeak# #-} +finalizeWeak# :: Weak# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #) +finalizeWeak# a1 a2 = GHC.Prim.finalizeWeak# a1 a2 +{-# NOINLINE touch# #-} +touch# :: a_levpoly -> State# s -> State# s +touch# a1 a2 = GHC.Prim.touch# a1 a2 +{-# NOINLINE makeStablePtr# #-} +makeStablePtr# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a_levpoly #) +makeStablePtr# a1 a2 = GHC.Prim.makeStablePtr# a1 a2 +{-# NOINLINE deRefStablePtr# #-} +deRefStablePtr# :: StablePtr# a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),a_levpoly #) +deRefStablePtr# a1 a2 = GHC.Prim.deRefStablePtr# a1 a2 +{-# NOINLINE eqStablePtr# #-} +eqStablePtr# :: StablePtr# a_levpoly -> StablePtr# a_levpoly -> Int# +eqStablePtr# a1 a2 = GHC.Prim.eqStablePtr# a1 a2 +{-# NOINLINE makeStableName# #-} +makeStableName# :: a_levpoly -> State# (RealWorld) -> (# State# (RealWorld),StableName# a_levpoly #) +makeStableName# a1 a2 = GHC.Prim.makeStableName# a1 a2 +{-# NOINLINE stableNameToInt# #-} +stableNameToInt# :: StableName# a_levpoly -> Int# +stableNameToInt# a1 = GHC.Prim.stableNameToInt# a1 +{-# NOINLINE compactNew# #-} +compactNew# :: Word# -> State# (RealWorld) -> (# State# (RealWorld),Compact# #) +compactNew# a1 a2 = GHC.Prim.compactNew# a1 a2 +{-# NOINLINE compactResize# #-} +compactResize# :: Compact# -> Word# -> State# (RealWorld) -> State# (RealWorld) +compactResize# a1 a2 a3 = GHC.Prim.compactResize# a1 a2 a3 +{-# NOINLINE compactContains# #-} +compactContains# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),Int# #) +compactContains# a1 a2 a3 = GHC.Prim.compactContains# a1 a2 a3 +{-# NOINLINE compactContainsAny# #-} +compactContainsAny# :: a -> State# (RealWorld) -> (# State# (RealWorld),Int# #) +compactContainsAny# a1 a2 = GHC.Prim.compactContainsAny# a1 a2 +{-# NOINLINE compactGetFirstBlock# #-} +compactGetFirstBlock# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #) +compactGetFirstBlock# a1 a2 = GHC.Prim.compactGetFirstBlock# a1 a2 +{-# NOINLINE compactGetNextBlock# #-} +compactGetNextBlock# :: Compact# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #) +compactGetNextBlock# a1 a2 a3 = GHC.Prim.compactGetNextBlock# a1 a2 a3 +{-# NOINLINE compactAllocateBlock# #-} +compactAllocateBlock# :: Word# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr# #) +compactAllocateBlock# a1 a2 a3 = GHC.Prim.compactAllocateBlock# a1 a2 a3 +{-# NOINLINE compactFixupPointers# #-} +compactFixupPointers# :: Addr# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Compact#,Addr# #) +compactFixupPointers# a1 a2 a3 = GHC.Prim.compactFixupPointers# a1 a2 a3 +{-# NOINLINE compactAdd# #-} +compactAdd# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #) +compactAdd# a1 a2 a3 = GHC.Prim.compactAdd# a1 a2 a3 +{-# NOINLINE compactAddWithSharing# #-} +compactAddWithSharing# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #) +compactAddWithSharing# a1 a2 a3 = GHC.Prim.compactAddWithSharing# a1 a2 a3 +{-# NOINLINE compactSize# #-} +compactSize# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Word# #) +compactSize# a1 a2 = GHC.Prim.compactSize# a1 a2 +{-# NOINLINE reallyUnsafePtrEquality# #-} +reallyUnsafePtrEquality# :: a_levpoly -> b_levpoly -> Int# +reallyUnsafePtrEquality# a1 a2 = GHC.Prim.reallyUnsafePtrEquality# a1 a2 +{-# NOINLINE par# #-} +par# :: a -> Int# +par# a1 = GHC.Prim.par# a1 +{-# NOINLINE spark# #-} +spark# :: a -> State# s -> (# State# s,a #) +spark# a1 a2 = GHC.Prim.spark# a1 a2 +{-# NOINLINE getSpark# #-} +getSpark# :: State# s -> (# State# s,Int#,a #) +getSpark# a1 = GHC.Prim.getSpark# a1 +{-# NOINLINE numSparks# #-} +numSparks# :: State# s -> (# State# s,Int# #) +numSparks# a1 = GHC.Prim.numSparks# a1 +{-# NOINLINE keepAlive# #-} +keepAlive# :: a_levpoly -> State# s -> (State# s -> b_reppoly) -> b_reppoly +keepAlive# a1 a2 a3 = GHC.Prim.keepAlive# a1 a2 a3 +{-# NOINLINE dataToTagSmall# #-} +dataToTagSmall# :: a_levpoly -> Int# +dataToTagSmall# a1 = GHC.Prim.dataToTagSmall# a1 +{-# NOINLINE dataToTagLarge# #-} +dataToTagLarge# :: a_levpoly -> Int# +dataToTagLarge# a1 = GHC.Prim.dataToTagLarge# a1 +{-# NOINLINE addrToAny# #-} +addrToAny# :: Addr# -> (# a_levpoly #) +addrToAny# a1 = GHC.Prim.addrToAny# a1 +{-# NOINLINE anyToAddr# #-} +anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #) +anyToAddr# a1 a2 = GHC.Prim.anyToAddr# a1 a2 +{-# NOINLINE mkApUpd0# #-} +mkApUpd0# :: BCO -> (# a #) +mkApUpd0# a1 = GHC.Prim.mkApUpd0# a1 +{-# NOINLINE newBCO# #-} +newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO #) +newBCO# a1 a2 a3 a4 a5 a6 = GHC.Prim.newBCO# a1 a2 a3 a4 a5 a6 +{-# NOINLINE unpackClosure# #-} +unpackClosure# :: a -> (# Addr#,ByteArray#,Array# b #) +unpackClosure# a1 = GHC.Prim.unpackClosure# a1 +{-# NOINLINE closureSize# #-} +closureSize# :: a -> Int# +closureSize# a1 = GHC.Prim.closureSize# a1 +{-# NOINLINE getApStackVal# #-} +getApStackVal# :: a -> Int# -> (# Int#,b #) +getApStackVal# a1 a2 = GHC.Prim.getApStackVal# a1 a2 +{-# NOINLINE getCCSOf# #-} +getCCSOf# :: a -> State# s -> (# State# s,Addr# #) +getCCSOf# a1 a2 = GHC.Prim.getCCSOf# a1 a2 +{-# NOINLINE getCurrentCCS# #-} +getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) +getCurrentCCS# a1 a2 = GHC.Prim.getCurrentCCS# a1 a2 +{-# NOINLINE clearCCS# #-} +clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #) +clearCCS# a1 a2 = GHC.Prim.clearCCS# a1 a2 +{-# NOINLINE whereFrom# #-} +whereFrom# :: a -> Addr# -> State# s -> (# State# s,Int# #) +whereFrom# a1 a2 a3 = GHC.Prim.whereFrom# a1 a2 a3 +{-# NOINLINE traceEvent# #-} +traceEvent# :: Addr# -> State# s -> State# s +traceEvent# a1 a2 = GHC.Prim.traceEvent# a1 a2 +{-# NOINLINE traceBinaryEvent# #-} +traceBinaryEvent# :: Addr# -> Int# -> State# s -> State# s +traceBinaryEvent# a1 a2 a3 = GHC.Prim.traceBinaryEvent# a1 a2 a3 +{-# NOINLINE traceMarker# #-} +traceMarker# :: Addr# -> State# s -> State# s +traceMarker# a1 a2 = GHC.Prim.traceMarker# a1 a2 +{-# NOINLINE setThreadAllocationCounter# #-} +setThreadAllocationCounter# :: Int64# -> State# (RealWorld) -> State# (RealWorld) +setThreadAllocationCounter# a1 a2 = GHC.Prim.setThreadAllocationCounter# a1 a2 +{-# NOINLINE prefetchByteArray3# #-} +prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray3# a1 a2 a3 = GHC.Prim.prefetchByteArray3# a1 a2 a3 +{-# NOINLINE prefetchMutableByteArray3# #-} +prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray3# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray3# a1 a2 a3 +{-# NOINLINE prefetchAddr3# #-} +prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr3# a1 a2 a3 = GHC.Prim.prefetchAddr3# a1 a2 a3 +{-# NOINLINE prefetchValue3# #-} +prefetchValue3# :: a -> State# s -> State# s +prefetchValue3# a1 a2 = GHC.Prim.prefetchValue3# a1 a2 +{-# NOINLINE prefetchByteArray2# #-} +prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray2# a1 a2 a3 = GHC.Prim.prefetchByteArray2# a1 a2 a3 +{-# NOINLINE prefetchMutableByteArray2# #-} +prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray2# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray2# a1 a2 a3 +{-# NOINLINE prefetchAddr2# #-} +prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr2# a1 a2 a3 = GHC.Prim.prefetchAddr2# a1 a2 a3 +{-# NOINLINE prefetchValue2# #-} +prefetchValue2# :: a -> State# s -> State# s +prefetchValue2# a1 a2 = GHC.Prim.prefetchValue2# a1 a2 +{-# NOINLINE prefetchByteArray1# #-} +prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray1# a1 a2 a3 = GHC.Prim.prefetchByteArray1# a1 a2 a3 +{-# NOINLINE prefetchMutableByteArray1# #-} +prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray1# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray1# a1 a2 a3 +{-# NOINLINE prefetchAddr1# #-} +prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr1# a1 a2 a3 = GHC.Prim.prefetchAddr1# a1 a2 a3 +{-# NOINLINE prefetchValue1# #-} +prefetchValue1# :: a -> State# s -> State# s +prefetchValue1# a1 a2 = GHC.Prim.prefetchValue1# a1 a2 +{-# NOINLINE prefetchByteArray0# #-} +prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray0# a1 a2 a3 = GHC.Prim.prefetchByteArray0# a1 a2 a3 +{-# NOINLINE prefetchMutableByteArray0# #-} +prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray0# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray0# a1 a2 a3 +{-# NOINLINE prefetchAddr0# #-} +prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr0# a1 a2 a3 = GHC.Prim.prefetchAddr0# a1 a2 a3 +{-# NOINLINE prefetchValue0# #-} +prefetchValue0# :: a -> State# s -> State# s +prefetchValue0# a1 a2 = GHC.Prim.prefetchValue0# a1 a2 diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs --- a/GHC/Tuple.hs +++ b/GHC/Tuple.hs @@ -1,37 +1,52 @@ {-# 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 -import GHC.CString () -- Make sure we do it first, so that the - -- implicit Typeable stuff can see GHC.Types.TyCon - -- and unpackCString# etc +-- 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 = () -- The desugarer uses 1-tuples, --- but "()" is already used up for 0-tuples +-- but "Unit" is already used up for 0-tuples -- See Note [One-tuples] in GHC.Builtin.Types --- | @Solo@ is the canonical lifted 1-tuple, just like '(,)' is the canonical --- lifted 2-tuple (pair) and '(,,)' is the canonical lifted 3-tuple (triple). +-- | @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", @@ -77,156 +92,509 @@ -- 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 = Solo a +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 (Solo a) = a +getSolo (MkSolo a) = a -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) +-- | A tuple of zero elements, a synonym for 'Unit'. +-- +-- @since 0.11.0 +-- +type Tuple0 = Unit -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,a1) +-- | 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) -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,a1,b1) + +-- | 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) -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,a1,b1,c1) + +-- | 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) -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,a1,b1,c1,d1) + +-- | 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) -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,a1,b1,c1,d1,e1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, - r1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, - r1,s1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, - r1,s1,t1) + +-- | 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) -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,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, - r1,s1,t1,u1) + +-- | 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 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) -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,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 tuple of 64 elements. +-- +-- @since 0.11.0 +-- +data Tuple64 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2 = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2) diff --git a/GHC/Types.hs b/GHC/Types.hs --- a/GHC/Types.hs +++ b/GHC/Types.hs @@ -1,551 +1,3677 @@ {-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples, MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators, - PolyKinds, NegativeLiterals, DataKinds #-} --- NegativeLiterals: see Note [Fixity of (->)] ------------------------------------------------------------------------------ --- | --- 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 ( - -- Data types that are built-in syntax - -- They are defined here, but not explicitly exported - -- - -- Lists: []( [], (:) ) - -- Type equality: (~)( Eq# ) - - Bool(..), Char(..), Int(..), Word(..), - Float(..), Double(..), - Ordering(..), IO(..), - isTrue#, - SPEC(..), - Symbol, - Any, - type (~~), Coercible, - TYPE, 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. - VecCount(..), VecElem(..), - Void#, - - -- * Runtime type representation - Module(..), TrName(..), TyCon(..), TypeLitSort(..), - KindRep(..), KindBndr, - - -- * Multiplicity Types - Multiplicity(..), MultMul - ) 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 kind of constraints, like @Show a@ -data Constraint - --- | The runtime representation of lifted types. -type LiftedRep = 'BoxedRep 'Lifted - --- | The runtime representation of unlifted types. -type UnliftedRep = 'BoxedRep 'Unlifted - --- | 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 - -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. --- Declared here because class IP needs it -data Symbol - -{- ********************************************************************* -* * - Any -* * -********************************************************************* -} - --- | The type constructor 'Any' is type to which you can unsafely coerce any --- lifted type, and back. More concretely, for a lifted type @t@ and --- value @x :: t@, -- @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent --- to @x@. --- -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 list type, usually written in its non-prefix form @[a]@. --- --- ==== __Examples__ --- --- Unless the OverloadedLists extension is enabled, list literals are --- syntatic sugar for repeated applications of @:@ and @[]@. --- --- >>> 1:2:3:4:[] == [1,2,3,4] --- True --- --- Similarly, unless the OverloadedStrings extension is enabled, string --- literals are syntactic sugar for a lists of characters. --- --- >>> ['h','e','l','l','o'] == "hello" --- True --- -data [] a = [] | a : [a] - - -{- ********************************************************************* -* * - Ordering -* * -********************************************************************* -} - -data Ordering = LT | EQ | GT - - -{- ********************************************************************* -* * - Int, Char, Word, Float, Double -* * -********************************************************************* -} - -{- | The character type 'Char' is an enumeration whose values represent -Unicode (or equivalently ISO\/IEC 10646) code points (i.e. characters, see - for details). This set extends the ISO 8859-1 -(Latin-1) character set (the first 256 characters), which is itself an extension -of the ASCII character set (the first 128 characters). A character literal in -Haskell has type 'Char'. - -To convert a 'Char' to or from the corresponding 'Int' value defined -by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the -'Prelude.Enum' class respectively (or equivalently 'Data.Char.ord' and -'Data.Char.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# - - -{- ********************************************************************* -* * - 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 - - NB: (~) is built-in syntax, and hence not explicitly exported -* * -********************************************************************* -} - -{- -Note [Kind-changing of (~) and Coercible] -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -(~) and Coercible are tricky to define. To the user, they must appear as -constraints, but we cannot define them as such in Haskell. But we also cannot -just define them only in GHC.Prim (like (->)), because we need a real module -for them, e.g. to compile the constructor's info table. - -Furthermore the type of MkCoercible cannot be written in Haskell -(no syntax for ~#R). - -So we define them as regular data types in GHC.Types, and do magic in GHC.Builtin.Types, -inside GHC, to change the kind and type. --} - - --- | Lifted, heterogeneous equality. By lifted, we mean that it --- can be bogus (deferred type error). By heterogeneous, the two --- types @a@ and @b@ might have different kinds. Because @~~@ can --- appear unexpectedly in error messages to users who do not care --- about the difference between heterogeneous equality @~~@ and --- homogeneous equality @~@, this is printed as @~@ unless --- @-fprint-equality-relations@ is set. --- --- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~~:'. -class a ~~ b - - -- See also Note [The equality types story] in GHC.Builtin.Types.Prim - --- | Lifted, homogeneous equality. By lifted, we mean that it --- can be bogus (deferred type error). By homogeneous, the two --- types @a@ and @b@ must have the same kinds. - --- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~:'. -class a ~ b - -infix 4 ~, ~~ - -- See also Note [The equality types story] in GHC.Builtin.Types.Prim - --- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ if --- the compiler can infer that they have the same representation. This class --- does not have regular instances; instead they are created on-the-fly during --- type-checking. Trying to manually declare an instance of @Coercible@ --- is an error. --- --- Nevertheless one can pretend that the following three kinds of instances --- exist. First, as a trivial base-case: --- --- @instance Coercible a a@ --- --- Furthermore, for every type constructor there is --- an instance that allows to coerce under the type constructor. For --- example, let @D@ be a prototypical type constructor (@data@ or --- @newtype@) with three type arguments, which have roles @nominal@, --- @representational@ resp. @phantom@. Then there is an instance of --- the form --- --- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@ --- --- Note that the @nominal@ type arguments are equal, the --- @representational@ type arguments can differ, but need to have a --- @Coercible@ instance themself, and the @phantom@ type arguments can be --- changed arbitrarily. --- --- The third kind of instance exists for every @newtype NT = MkNT T@ and --- comes in two variants, namely --- --- @instance Coercible a T => Coercible a NT@ --- --- @instance Coercible T b => Coercible NT b@ --- --- This instance is only usable if the constructor @MkNT@ is in scope. --- --- If, as a library author of a type constructor like @Set a@, you --- want to prevent a user of your module to write --- @coerce :: Set T -> Set NT@, --- you need to set the role of @Set@\'s type parameter to @nominal@, --- by writing --- --- @type role Set nominal@ --- --- For more details about this feature, please refer to --- --- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich. --- --- @since 4.7.0.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. -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 (on 32-bit only) - | 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 (on 32-bit only) - | 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 RuntimeRep] 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# = (# #) - -{- ********************************************************************* -* * - 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 - -#if WORD_SIZE_IN_BITS < 64 -#define WORD64_TY Word64# -#else -#define WORD64_TY Word# -#endif - --- | 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_TY -- ^ Fingerprint (high) - WORD64_TY -- ^ 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 + PolyKinds, NegativeLiterals, DataKinds, ScopedTypeVariables, + TypeApplications, StandaloneKindSignatures, GADTs, + FlexibleInstances, UndecidableInstances, UnboxedSums #-} +-- NegativeLiterals: see Note [Fixity of (->)] +{-# OPTIONS_HADDOCK print-explicit-runtime-reps #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Types +-- Copyright : (c) The University of Glasgow 2009 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : ghc-devs@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- GHC type definitions. +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.Types ( + -- * Built-in types + Bool(..), Char(..), Int(..), Word(..), + Float(..), Double(..), + Ordering(..), IO(..), + + List, -- List( [], (:) ) + -- List constructors are not exported + -- because they are built-in syntax + + isTrue#, + SPEC(..), + Symbol, + Any, + + -- * Type equality + type (~), type (~~), Coercible, + + -- * Representation polymorphism + TYPE, CONSTRAINT, + Levity(..), RuntimeRep(..), + LiftedRep, UnliftedRep, + Type, UnliftedType, Constraint, + -- The historical type * should ideally be written as + -- `type *`, without the parentheses. But that's a true + -- pain to parse, and for little gain. + ZeroBitRep, ZeroBitType, + VecCount(..), VecElem(..), + Void#, + + -- * Boxing constructors + DictBox( MkDictBox ), + WordBox( MkWordBox), IntBox( MkIntBox), + FloatBox( MkFloatBox), DoubleBox( MkDoubleBox), + + -- * Multiplicity types + Multiplicity(..), MultMul, + + -- * Runtime type representation + Module(..), TrName(..), TyCon(..), TypeLitSort(..), + KindRep(..), KindBndr, + + -- * Unboxed tuples + Unit#, + Solo#(..), + Tuple0#, + Tuple1#, + Tuple2#, + Tuple3#, + Tuple4#, + Tuple5#, + Tuple6#, + Tuple7#, + Tuple8#, + Tuple9#, + Tuple10#, + Tuple11#, + Tuple12#, + Tuple13#, + Tuple14#, + Tuple15#, + Tuple16#, + Tuple17#, + Tuple18#, + Tuple19#, + Tuple20#, + Tuple21#, + Tuple22#, + Tuple23#, + Tuple24#, + Tuple25#, + Tuple26#, + Tuple27#, + Tuple28#, + Tuple29#, + Tuple30#, + Tuple31#, + Tuple32#, + Tuple33#, + Tuple34#, + Tuple35#, + Tuple36#, + Tuple37#, + Tuple38#, + Tuple39#, + Tuple40#, + Tuple41#, + Tuple42#, + Tuple43#, + Tuple44#, + Tuple45#, + Tuple46#, + Tuple47#, + Tuple48#, + Tuple49#, + Tuple50#, + Tuple51#, + Tuple52#, + Tuple53#, + Tuple54#, + Tuple55#, + Tuple56#, + Tuple57#, + Tuple58#, + Tuple59#, + Tuple60#, + Tuple61#, + Tuple62#, + Tuple63#, + Tuple64#, + + -- * Unboxed sums + Sum2#, + Sum3#, + Sum4#, + Sum5#, + Sum6#, + Sum7#, + Sum8#, + Sum9#, + Sum10#, + Sum11#, + Sum12#, + Sum13#, + Sum14#, + Sum15#, + Sum16#, + Sum17#, + Sum18#, + Sum19#, + Sum20#, + Sum21#, + Sum22#, + Sum23#, + Sum24#, + Sum25#, + Sum26#, + Sum27#, + Sum28#, + Sum29#, + Sum30#, + Sum31#, + Sum32#, + Sum33#, + Sum34#, + Sum35#, + Sum36#, + Sum37#, + Sum38#, + Sum39#, + Sum40#, + Sum41#, + Sum42#, + Sum43#, + Sum44#, + Sum45#, + Sum46#, + Sum47#, + Sum48#, + Sum49#, + Sum50#, + Sum51#, + Sum52#, + Sum53#, + Sum54#, + Sum55#, + Sum56#, + Sum57#, + Sum58#, + Sum59#, + Sum60#, + Sum61#, + Sum62#, + Sum63#, + + ) where + +import GHC.Prim + +infixr 5 : + +{- ********************************************************************* +* * + Functions +* * +********************************************************************* -} + +infixr -1 -> +{- +Note [Fixity of (->)] +~~~~~~~~~~~~~~~~~~~~~ +This declaration is important for :info (->) command (issue #10145) +1) The parser parses -> as if it had lower fixity than 0, + so we conventionally use -1 (issue #15235). +2) Fixities outside the 0-9 range are exceptionally allowed + for (->) (see checkPrecP in RdrHsSyn) +3) The negative fixity -1 must be parsed as a single token, + hence this module requires NegativeLiterals. +-} + +-- | The regular function type +type (->) = FUN 'Many +-- See Note [Linear types] in Multiplicity + +{- ********************************************************************* +* * + Kinds +* * +********************************************************************* -} + + + +-- | The runtime representation of lifted types. +type LiftedRep = 'BoxedRep 'Lifted + +-- | The runtime representation of unlifted types. +type UnliftedRep = 'BoxedRep 'Unlifted + +-- | The runtime representation of a zero-width tuple, +-- represented by no bits at all +type ZeroBitRep = 'TupleRep '[] + +------------------------- +-- | The kind of lifted constraints +type Constraint = CONSTRAINT LiftedRep + +-- | The kind of types with lifted values. For example @Int :: Type@. +type Type = TYPE LiftedRep + +-- | The kind of boxed, unlifted values, for example @Array#@ or a user-defined +-- unlifted data type, using @-XUnliftedDataTypes@. +type UnliftedType = TYPE UnliftedRep + +-- | The kind of the empty unboxed tuple type (# #) +type ZeroBitType = TYPE ZeroBitRep + +------------------------- +data Multiplicity = Many | One + +type family MultMul (a :: Multiplicity) (b :: Multiplicity) :: Multiplicity where + MultMul 'One x = x + MultMul x 'One = x + MultMul 'Many x = 'Many + MultMul x 'Many = 'Many + +{- ********************************************************************* +* * + Symbol +* * +********************************************************************* -} + +-- | (Kind) This is the kind of type-level symbols. +data Symbol + +-- Symbol is declared here because class IP needs it + +{- ********************************************************************* +* * + Any +* * +********************************************************************* -} + +-- | The type constructor @Any :: forall k. k@ is a type to which you can unsafely coerce any type, and back. +-- +-- For @unsafeCoerce@ this means for all lifted types @t@ that +-- @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent to @x@ and safe. +-- +-- The same is true for *all* types when using +-- @ +-- unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) +-- (a :: TYPE r1) (b :: TYPE r2). +-- a -> b +-- @ +-- but /only/ if you instantiate @r1@ and @r2@ to the /same/ runtime representation. +-- For example using @(unsafeCoerce# :: forall (a :: TYPE IntRep) (b :: TYPE IntRep). a -> b) x@ +-- is fine, but @(unsafeCoerce# :: forall (a :: TYPE IntRep) (b :: TYPE FloatRep). a -> b)@ +-- will likely cause seg-faults or worse. +-- For this resason, users should always prefer unsafeCoerce over unsafeCoerce# when possible. +-- +-- Here are some more examples: +-- @ +-- bad_a1 :: Any @(TYPE 'IntRep) +-- bad_a1 = unsafeCoerce# True +-- +-- bad_a2 :: Any @(TYPE ('BoxedRep 'UnliftedRep)) +-- bad_a2 = unsafeCoerce# True +-- @ +-- Here @bad_a1@ is bad because we started with @True :: (Bool :: Type)@, represented by a boxed heap pointer, +-- and coerced it to @a1 :: Any @(TYPE 'IntRep)@, whose representation is a non-pointer integer. +-- That's why we had to use `unsafeCoerce#`; it is really unsafe because it can change representations. +-- Similarly @bad_a2@ is bad because although both @True@ and @bad_a2@ are represented by a heap pointer, +-- @True@ is lifted but @bad_a2@ is not; bugs here may be rather subtle. +-- +-- If you must use unsafeCoerce# to cast to `Any`, type annotations are recommended +-- to make sure that @Any@ has the correct kind. As casting between different runtimereps is +-- unsound. For example to cast a @ByteArray#@ to @Any@ you might use: +-- @ +-- unsafeCoerce# b :: (Any :: TYPE ('BoxedRep 'Unlifted)) +-- @ +type family Any :: k where { } +-- See Note [Any types] in GHC.Builtin.Types. Also, for a bit of history on Any see +-- #10886. Note that this must be a *closed* type family: we need to ensure +-- that this can't reduce to a `data` type for the results discussed in +-- Note [Any types]. + +{- ********************************************************************* +* * + Lists + + NB: lists are built-in syntax, and hence not explicitly exported +* * +********************************************************************* -} + +-- | The builtin linked list type. +-- +-- In Haskell, lists are one of the most important data types as they are +-- often used analogous to loops in imperative programming languages. +-- These lists are singly linked, which makes them unsuited for operations +-- that require \(\mathcal{O}(1)\) access. Instead, they are intended to +-- be traversed. +-- +-- You can use @List a@ or @[a]@ in type signatures: +-- +-- > length :: [a] -> Int +-- +-- or +-- +-- > length :: List a -> Int +-- +-- They are fully equivalent, and @List a@ will be normalised to @[a]@. +-- +-- ==== Usage +-- +-- Lists are constructed recursively using the right-associative constructor operator (or /cons/) +-- @(:) :: a -> [a] -> [a]@, which prepends an element to a list, +-- and the empty list @[]@. +-- +-- @ +-- (1 : 2 : 3 : []) == (1 : (2 : (3 : []))) == [1, 2, 3] +-- @ +-- +-- Lists can also be constructed using list literals +-- of the form @[x_1, x_2, ..., x_n]@ +-- which are syntactic sugar and, unless @-XOverloadedLists@ is enabled, +-- are translated into uses of @(:)@ and @[]@ +-- +-- 'Data.String.String' literals, like @"I 💜 hs"@, are translated into +-- Lists of characters, @[\'I\', \' \', \'💜\', \' \', \'h\', \'s\']@. +-- +-- ==== __Implementation__ +-- +-- Internally and in memory, all the above are represented like this, +-- with arrows being pointers to locations in memory. +-- +-- > ╭───┬───┬──╮ ╭───┬───┬──╮ ╭───┬───┬──╮ ╭────╮ +-- > │(:)│ │ ─┼──>│(:)│ │ ─┼──>│(:)│ │ ─┼──>│ [] │ +-- > ╰───┴─┼─┴──╯ ╰───┴─┼─┴──╯ ╰───┴─┼─┴──╯ ╰────╯ +-- > v v v +-- > 1 2 3 +-- +-- ==== __Examples__ +-- +-- @ +-- >>> [\'H\', \'a\', \'s\', \'k\', \'e\', \'l\', \'l\'] +-- \"Haskell\" +-- @ +-- +-- @ +-- >>> 1 : [4, 1, 5, 9] +-- [1,4,1,5,9] +-- @ +-- +-- @ +-- >>> [] : [] : [] +-- [[],[]] +-- @ +-- +-- @since 0.10.0 +-- +data List a = [] | a : List a + + +{- ********************************************************************* +* * + Ordering +* * +********************************************************************* -} + +data Ordering = LT | EQ | GT + + +{- ********************************************************************* +* * + Int, Char, Word, Float, Double +* * +********************************************************************* -} + +{- | The character type 'Char' represents Unicode codespace +and its elements are code points as in definitions +[D9 and D10 of the Unicode Standard](https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf#G2212). + +Character literals in Haskell are single-quoted: @\'Q\'@, @\'Я\'@ or @\'Ω\'@. +To represent a single quote itself use @\'\\''@, and to represent a backslash +use @\'\\\\\'@. The full grammar can be found in the section 2.6 of the +[Haskell 2010 Language Report](https://www.haskell.org/definition/haskell2010.pdf#section.2.6). + +To specify a character by its code point one can use decimal, hexadecimal +or octal notation: @\'\\65\'@, @\'\\x41\'@ and @\'\\o101\'@ are all alternative forms +of @\'A\'@. The largest code point is @\'\\x10ffff\'@. + +There is a special escape syntax for ASCII control characters: + ++-------------+-------------------+---------------------------+ +| Escape | Alternatives | Meaning | ++=============+===================+===========================+ +| @'\\NUL'@ | @'\\0'@ | null character | ++-------------+-------------------+---------------------------+ +| @'\\SOH'@ | @'\\1'@ | start of heading | ++-------------+-------------------+---------------------------+ +| @'\\STX'@ | @'\\2'@ | start of text | ++-------------+-------------------+---------------------------+ +| @'\\ETX'@ | @'\\3'@ | end of text | ++-------------+-------------------+---------------------------+ +| @'\\EOT'@ | @'\\4'@ | end of transmission | ++-------------+-------------------+---------------------------+ +| @'\\ENQ'@ | @'\\5'@ | enquiry | ++-------------+-------------------+---------------------------+ +| @'\\ACK'@ | @'\\6'@ | acknowledge | ++-------------+-------------------+---------------------------+ +| @'\\BEL'@ | @'\\7'@, @'\\a'@ | bell (alert) | ++-------------+-------------------+---------------------------+ +| @'\\BS'@ | @'\\8'@, @'\\b'@ | backspace | ++-------------+-------------------+---------------------------+ +| @'\\HT'@ | @'\\9'@, @'\\t'@ | horizontal tab | ++-------------+-------------------+---------------------------+ +| @'\\LF'@ | @'\\10'@, @'\\n'@ | line feed (new line) | ++-------------+-------------------+---------------------------+ +| @'\\VT'@ | @'\\11'@, @'\\v'@ | vertical tab | ++-------------+-------------------+---------------------------+ +| @'\\FF'@ | @'\\12'@, @'\\f'@ | form feed | ++-------------+-------------------+---------------------------+ +| @'\\CR'@ | @'\\13'@, @'\\r'@ | carriage return | ++-------------+-------------------+---------------------------+ +| @'\\SO'@ | @'\\14'@ | shift out | ++-------------+-------------------+---------------------------+ +| @'\\SI'@ | @'\\15'@ | shift in | ++-------------+-------------------+---------------------------+ +| @'\\DLE'@ | @'\\16'@ | data link escape | ++-------------+-------------------+---------------------------+ +| @'\\DC1'@ | @'\\17'@ | device control 1 | ++-------------+-------------------+---------------------------+ +| @'\\DC2'@ | @'\\18'@ | device control 2 | ++-------------+-------------------+---------------------------+ +| @'\\DC3'@ | @'\\19'@ | device control 3 | ++-------------+-------------------+---------------------------+ +| @'\\DC4'@ | @'\\20'@ | device control 4 | ++-------------+-------------------+---------------------------+ +| @'\\NAK'@ | @'\\21'@ | negative acknowledge | ++-------------+-------------------+---------------------------+ +| @'\\SYN'@ | @'\\22'@ | synchronous idle | ++-------------+-------------------+---------------------------+ +| @'\\ETB'@ | @'\\23'@ | end of transmission block | ++-------------+-------------------+---------------------------+ +| @'\\CAN'@ | @'\\24'@ | cancel | ++-------------+-------------------+---------------------------+ +| @'\\EM'@ | @'\\25'@ | end of medium | ++-------------+-------------------+---------------------------+ +| @'\\SUB'@ | @'\\26'@ | substitute | ++-------------+-------------------+---------------------------+ +| @'\\ESC'@ | @'\\27'@ | escape | ++-------------+-------------------+---------------------------+ +| @'\\FS'@ | @'\\28'@ | file separator | ++-------------+-------------------+---------------------------+ +| @'\\GS'@ | @'\\29'@ | group separator | ++-------------+-------------------+---------------------------+ +| @'\\RS'@ | @'\\30'@ | record separator | ++-------------+-------------------+---------------------------+ +| @'\\US'@ | @'\\31'@ | unit separator | ++-------------+-------------------+---------------------------+ +| @'\\SP'@ | @'\\32'@, @' '@ | space | ++-------------+-------------------+---------------------------+ +| @'\\DEL'@ | @'\\127'@ | delete | ++-------------+-------------------+---------------------------+ + +[Data.Char](https://hackage.haskell.org/package/base/docs/Data-Char.html) +provides utilities to work with 'Char'. + +-} +data {-# CTYPE "HsChar" #-} Char = C# Char# + +-- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@. +-- The exact range for a given implementation can be determined by using +-- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class. +data {-# CTYPE "HsInt" #-} Int = I# Int# + +-- |A 'Word' is an unsigned integral type, with the same size as 'Int'. +data {-# CTYPE "HsWord" #-} Word = W# Word# + +-- | Single-precision floating point numbers. +-- It is desirable that this type be at least equal in range and precision +-- to the IEEE single-precision type. +data {-# CTYPE "HsFloat" #-} Float = F# Float# + +-- | Double-precision floating point numbers. +-- It is desirable that this type be at least equal in range and precision +-- to the IEEE double-precision type. +data {-# CTYPE "HsDouble" #-} Double = D# Double# + + +{- ********************************************************************* +* * + IO +* * +********************************************************************* -} + +{- | +A value of type @'IO' a@ is a computation which, when performed, +does some I\/O before returning a value of type @a@. + +There is really only one way to \"perform\" an I\/O action: bind it to +@Main.main@ in your program. When your program is run, the I\/O will +be performed. It isn't possible to perform I\/O from an arbitrary +function, unless that function is itself in the 'IO' monad and called +at some point, directly or indirectly, from @Main.main@. + +'IO' is a monad, so 'IO' actions can be combined using either the do-notation +or the 'Prelude.>>' and 'Prelude.>>=' operations from the 'Prelude.Monad' +class. +-} +newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #)) + + +{- ********************************************************************* +* * + (~) and Coercible + +* * +********************************************************************* -} + +{- +Note [Kind-changing of (~) and Coercible] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +(~) and Coercible are tricky to define. To the user, they must appear as +constraints, but we cannot define them as such in Haskell. But we also cannot +just define them only in GHC.Prim (like (->)), because we need a real module +for them, e.g. to compile the constructor's info table. + +Furthermore the type of MkCoercible cannot be written in Haskell +(no syntax for ~#R). + +So we define them as regular data types in GHC.Types, and do magic in GHC.Builtin.Types, +inside GHC, to change the kind and type. +-} + + +-- | Lifted, heterogeneous equality. By lifted, we mean that it +-- can be bogus (deferred type error). By heterogeneous, the two +-- types @a@ and @b@ might have different kinds. Because @~~@ can +-- appear unexpectedly in error messages to users who do not care +-- about the difference between heterogeneous equality @~~@ and +-- homogeneous equality @~@, this is printed as @~@ unless +-- @-fprint-equality-relations@ is set. +-- +-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~~:'. +class a ~~ b + + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim + +-- | Lifted, homogeneous equality. By lifted, we mean that it +-- can be bogus (deferred type error). By homogeneous, the two +-- types @a@ and @b@ must have the same kinds. + +-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~:'. +class a ~ b + +infix 4 ~, ~~ + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim + +-- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ if +-- the compiler can infer that they have the same representation. This class +-- does not have regular instances; instead they are created on-the-fly during +-- type-checking. Trying to manually declare an instance of @Coercible@ +-- is an error. +-- +-- Nevertheless one can pretend that the following three kinds of instances +-- exist. First, as a trivial base-case: +-- +-- @instance Coercible a a@ +-- +-- Furthermore, for every type constructor there is +-- an instance that allows to coerce under the type constructor. For +-- example, let @D@ be a prototypical type constructor (@data@ or +-- @newtype@) with three type arguments, which have roles @nominal@, +-- @representational@ resp. @phantom@. Then there is an instance of +-- the form +-- +-- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@ +-- +-- Note that the @nominal@ type arguments are equal, the +-- @representational@ type arguments can differ, but need to have a +-- @Coercible@ instance themself, and the @phantom@ type arguments can be +-- changed arbitrarily. +-- +-- The third kind of instance exists for every @newtype NT = MkNT T@ and +-- comes in two variants, namely +-- +-- @instance Coercible a T => Coercible a NT@ +-- +-- @instance Coercible T b => Coercible NT b@ +-- +-- This instance is only usable if the constructor @MkNT@ is in scope. +-- +-- If, as a library author of a type constructor like @Set a@, you +-- want to prevent a user of your module to write +-- @coerce :: Set T -> Set NT@, +-- you need to set the role of @Set@\'s type parameter to @nominal@, +-- by writing +-- +-- @type role Set nominal@ +-- +-- For more details about this feature, please refer to +-- +-- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich. +-- +-- @since 0.4.0 +class Coercible (a :: k) (b :: k) + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim + +{- ********************************************************************* +* * + Bool, and isTrue# +* * +********************************************************************* -} + +data {-# CTYPE "HsBool" #-} Bool = False | True + +{-# INLINE isTrue# #-} +-- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False +-- if it is 0#. +isTrue# :: Int# -> Bool -- See Note [Optimizing isTrue#] +isTrue# x = tagToEnum# x + +{- Note [Optimizing isTrue#] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Current definition of isTrue# is a temporary workaround. We would like to +have functions isTrue# and isFalse# defined like this: + + isTrue# :: Int# -> Bool + isTrue# 1# = True + isTrue# _ = False + + isFalse# :: Int# -> Bool + isFalse# 0# = True + isFalse# _ = False + +These functions would allow us to safely check if a tag can represent True +or False. Using isTrue# and isFalse# as defined above will not introduce +additional case into the code. When we scrutinize return value of isTrue# +or isFalse#, either explicitly in a case expression or implicitly in a guard, +the result will always be a single case expression (given that optimizations +are turned on). This results from case-of-case transformation. Consider this +code (this is both valid Haskell and Core): + +case isTrue# (a ># b) of + True -> e1 + False -> e2 + +Inlining isTrue# gives: + +case (case (a ># b) of { 1# -> True; _ -> False } ) of + True -> e1 + False -> e2 + +Case-of-case transforms that to: + +case (a ># b) of + 1# -> case True of + True -> e1 + False -> e2 + _ -> case False of + True -> e1 + False -> e2 + +Which is then simplified by case-of-known-constructor: + +case (a ># b) of + 1# -> e1 + _ -> e2 + +While we get good Core here, the code generator will generate very bad Cmm +if e1 or e2 do allocation. It will push heap checks into case alternatives +which results in about 2.5% increase in code size. Until this is improved we +just make isTrue# an alias to tagToEnum#. This is a temporary solution (if +you're reading this in 2023 then things went wrong). See #8326. +-} + + +{- ********************************************************************* +* * + SPEC +* * +********************************************************************* -} + +-- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform +-- the compiler when to be particularly aggressive. In particular, it +-- tells GHC to specialize regardless of size or the number of +-- specializations. However, not all loops fall into this category. +-- +-- Libraries can specify this by using 'SPEC' data type to inform which +-- loops should be aggressively specialized. For example, +-- instead of +-- +-- > loop x where loop arg = ... +-- +-- write +-- +-- > loop SPEC x where loop !_ arg = ... +-- +-- There is no semantic difference between 'SPEC' and 'SPEC2', +-- we just need a type with two constructors lest it is optimised away +-- before @SpecConstr@. +-- +-- This type is reexported from "GHC.Exts" since GHC 9.0 and @base-4.15@. +-- For compatibility with earlier releases import it from "GHC.Types" +-- in @ghc-prim@ package. +-- +-- @since 0.3.1.0 +-- +data SPEC = SPEC | SPEC2 + + +{- ********************************************************************* +* * + Levity polymorphism +* * +********************************************************************* -} + +-- | Whether a boxed type is lifted or unlifted. +data Levity = Lifted | Unlifted + +-- | GHC maintains a property that the kind of all inhabited types +-- (as distinct from type constructors or type-level data) tells us +-- the runtime representation of values of that type. This datatype +-- encodes the choice of runtime value. +-- Note that 'TYPE' is parameterised by 'RuntimeRep'; this is precisely +-- what we mean by the fact that a type's kind encodes the runtime +-- representation. +-- +-- For boxed values (that is, values that are represented by a pointer), +-- a further distinction is made, between lifted types (that contain ⊥), +-- and unlifted ones (that don't). +data RuntimeRep = VecRep VecCount VecElem -- ^ a SIMD vector type + | TupleRep [RuntimeRep] -- ^ An unboxed tuple of the given reps + | SumRep [RuntimeRep] -- ^ An unboxed sum of the given reps + | BoxedRep Levity -- ^ boxed; represented by a pointer + | IntRep -- ^ signed, word-sized value + | Int8Rep -- ^ signed, 8-bit value + | Int16Rep -- ^ signed, 16-bit value + | Int32Rep -- ^ signed, 32-bit value + | Int64Rep -- ^ signed, 64-bit value + | WordRep -- ^ unsigned, word-sized value + | Word8Rep -- ^ unsigned, 8-bit value + | Word16Rep -- ^ unsigned, 16-bit value + | Word32Rep -- ^ unsigned, 32-bit value + | Word64Rep -- ^ unsigned, 64-bit value + | AddrRep -- ^ A pointer, but /not/ to a Haskell value + | FloatRep -- ^ a 32-bit floating point number + | DoubleRep -- ^ a 64-bit floating point number + +-- RuntimeRep is intimately tied to TyCon.RuntimeRep (in GHC proper). See +-- Note [RuntimeRep and PrimRep] in RepType. +-- See also Note [Wiring in RuntimeRep] in GHC.Builtin.Types +-- See also Note [TYPE and CONSTRAINT] in GHC.Builtin.Type.Prim + +-- | Length of a SIMD vector type +data VecCount = Vec2 + | Vec4 + | Vec8 + | Vec16 + | Vec32 + | Vec64 +-- Enum, Bounded instances in GHC.Enum + +-- | Element of a SIMD vector type +data VecElem = Int8ElemRep + | Int16ElemRep + | Int32ElemRep + | Int64ElemRep + | Word8ElemRep + | Word16ElemRep + | Word32ElemRep + | Word64ElemRep + | FloatElemRep + | DoubleElemRep +-- Enum, Bounded instances in GHC.Enum + +{-# DEPRECATED Void# "Void# is now an alias for the unboxed tuple (# #)." #-} +type Void# = (# #) + +{- ********************************************************************* +* * + Boxing data constructors +* * +********************************************************************* -} + +-- These "boxing" data types allow us to wrap up a value of kind (TYPE rr) +-- in a box of kind Type, for each rr. +data LiftBox (a :: TYPE UnliftedRep) = MkLiftBox a + +data IntBox (a :: TYPE IntRep) = MkIntBox a +data Int8Box (a :: TYPE Int8Rep) = MkInt8Box a +data Int16Box (a :: TYPE Int16Rep) = MkInt16Box a +data Int32Box (a :: TYPE Int32Rep) = MkInt32Box a +data Int64Box (a :: TYPE Int64Rep) = MkInt64Box a + +data WordBox (a :: TYPE WordRep) = MkWordBox a +data Word8Box (a :: TYPE Word8Rep) = MkWord8Box a +data Word16Box (a :: TYPE Word16Rep) = MkWord16Box a +data Word32Box (a :: TYPE Word32Rep) = MkWord32Box a +data Word64Box (a :: TYPE Word64Rep) = MkWord64Box a + +data FloatBox (a :: TYPE FloatRep) = MkFloatBox a +data DoubleBox (a :: TYPE DoubleRep) = MkDoubleBox a + +-- | Data type `Dict` provides a simple way to wrap up a (lifted) +-- constraint as a type +data DictBox c where + MkDictBox :: c => DictBox c + + +{- ********************************************************************* +* * + Runtime representation of TyCon +* * +********************************************************************* -} + +{- Note [Runtime representation of modules and tycons] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +We generate a binding for M.$modName and M.$tcT for every module M and +data type T. Things to think about + + - We want them to be economical on space; ideally pure data with no thunks. + + - We do this for every module (except this module GHC.Types), so we can't + depend on anything else (eg string unpacking code) + +That's why we have these terribly low-level representations. The TrName +type lets us use the TrNameS constructor when allocating static data; +but we also need TrNameD for the case where we are deserialising a TyCon +or Module (for example when deserialising a TypeRep), in which case we +can't conveniently come up with an Addr#. +-} + +#include "MachDeps.h" + +data Module = Module + TrName -- ^ Package name + TrName -- ^ Module name + +data TrName + = TrNameS Addr# -- ^ Static + | TrNameD [Char] -- ^ Dynamic + +-- | A de Bruijn index for a binder within a 'KindRep'. +type KindBndr = Int + +-- | The representation produced by GHC for conjuring up the kind of a +-- 'Data.Typeable.TypeRep'. + +-- See Note [Representing TyCon kinds: KindRep] in GHC.Tc.Instance.Typeable. +data KindRep = KindRepTyConApp TyCon [KindRep] + | KindRepVar !KindBndr + | KindRepApp KindRep KindRep + | KindRepFun KindRep KindRep + | KindRepTYPE !RuntimeRep + | KindRepTypeLitS TypeLitSort Addr# + | KindRepTypeLitD TypeLitSort [Char] + +data TypeLitSort = TypeLitSymbol + | TypeLitNat + | TypeLitChar + +-- Show instance for TyCon found in GHC.Show +data TyCon = TyCon Word64# -- ^ Fingerprint (high) + Word64# -- ^ Fingerprint (low) + Module -- ^ Module in which this is defined + TrName -- ^ Type constructor name + Int# -- ^ How many kind variables do we accept? + KindRep -- ^ A representation of the type's kind + +{- ********************************************************************* +* * + Unboxed tuples and sums +* * +********************************************************************* -} + +type Unit# :: TYPE (TupleRep '[]) +data Unit# = (# #) + +type Solo# :: TYPE rep -> TYPE (TupleRep '[rep]) +data Solo# a = MkSolo# a + +type Tuple0# = Unit# +type Tuple1# = Solo# + +type Tuple2# :: TYPE r1 -> TYPE r2 -> TYPE (TupleRep [r1, r2]) +data Tuple2# a b = + (# a,b #) +type Tuple3# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE (TupleRep [r1, r2, r3]) +data Tuple3# a b c = + (# a,b,c #) +type Tuple4# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE (TupleRep [r1, r2, r3, r4]) +data Tuple4# a b c d = + (# a,b,c,d #) +type Tuple5# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE (TupleRep [r1, r2, r3, r4, r5]) +data Tuple5# a b c d e = + (# a,b,c,d,e #) +type Tuple6# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6]) +data Tuple6# a b c d e f = + (# a,b,c,d,e,f #) +type Tuple7# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7]) +data Tuple7# a b c d e f g = + (# a,b,c,d,e,f,g #) +type Tuple8# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8]) +data Tuple8# a b c d e f g h = + (# a,b,c,d,e,f,g,h #) +type Tuple9# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9]) +data Tuple9# a b c d e f g h i = + (# a,b,c,d,e,f,g,h,i #) +type Tuple10# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10]) +data Tuple10# a b c d e f g h i j = + (# a,b,c,d,e,f,g,h,i,j #) +type Tuple11# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11]) +data Tuple11# a b c d e f g h i j k = + (# a,b,c,d,e,f,g,h,i,j,k #) +type Tuple12# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12]) +data Tuple12# a b c d e f g h i j k l = + (# a,b,c,d,e,f,g,h,i,j,k,l #) +type Tuple13# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13]) +data Tuple13# a b c d e f g h i j k l m = + (# a,b,c,d,e,f,g,h,i,j,k,l,m #) +type Tuple14# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14]) +data Tuple14# a b c d e f g h i j k l m n = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n #) +type Tuple15# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15]) +data Tuple15# a b c d e f g h i j k l m n o = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o #) +type Tuple16# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16]) +data Tuple16# a b c d e f g h i j k l m n o p = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p #) +type Tuple17# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17]) +data Tuple17# a b c d e f g h i j k l m n o p q = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q #) +type Tuple18# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18]) +data Tuple18# a b c d e f g h i j k l m n o p q r = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r #) +type Tuple19# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19]) +data Tuple19# a b c d e f g h i j k l m n o p q r s = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s #) +type Tuple20# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20]) +data Tuple20# a b c d e f g h i j k l m n o p q r s t = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t #) +type Tuple21# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21]) +data Tuple21# a b c d e f g h i j k l m n o p q r s t u = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u #) +type Tuple22# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22]) +data Tuple22# a b c d e f g h i j k l m n o p q r s t u v = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v #) +type Tuple23# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23]) +data Tuple23# a b c d e f g h i j k l m n o p q r s t u v w = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w #) +type Tuple24# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24]) +data Tuple24# a b c d e f g h i j k l m n o p q r s t u v w x = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x #) +type Tuple25# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25]) +data Tuple25# a b c d e f g h i j k l m n o p q r s t u v w x y = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y #) +type Tuple26# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26]) +data Tuple26# a b c d e f g h i j k l m n o p q r s t u v w x y z = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z #) +type Tuple27# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27]) +data Tuple27# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1 #) +type Tuple28# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28]) +data Tuple28# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1 #) +type Tuple29# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29]) +data Tuple29# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1 #) +type Tuple30# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30]) +data Tuple30# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1 #) +type Tuple31# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31]) +data Tuple31# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1 #) +type Tuple32# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32]) +data Tuple32# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1 #) +type Tuple33# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33]) +data Tuple33# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1 #) +type Tuple34# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34]) +data Tuple34# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1 #) +type Tuple35# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35]) +data Tuple35# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1 #) +type Tuple36# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36]) +data Tuple36# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1 #) +type Tuple37# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37]) +data Tuple37# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1 #) +type Tuple38# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38]) +data Tuple38# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1 #) +type Tuple39# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39]) +data Tuple39# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1 #) +type Tuple40# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40]) +data Tuple40# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1 #) +type Tuple41# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41]) +data Tuple41# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1 #) +type Tuple42# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42]) +data Tuple42# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1 #) +type Tuple43# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43]) +data Tuple43# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1 #) +type Tuple44# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44]) +data Tuple44# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1 #) +type Tuple45# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45]) +data Tuple45# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1 #) +type Tuple46# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46]) +data Tuple46# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1 #) +type Tuple47# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47]) +data Tuple47# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1 #) +type Tuple48# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48]) +data Tuple48# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1 #) +type Tuple49# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49]) +data Tuple49# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1 #) +type Tuple50# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50]) +data Tuple50# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1 #) +type Tuple51# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51]) +data Tuple51# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1 #) +type Tuple52# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52]) +data Tuple52# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1 #) +type Tuple53# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53]) +data Tuple53# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2 #) +type Tuple54# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54]) +data Tuple54# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2 #) +type Tuple55# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55]) +data Tuple55# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2 #) +type Tuple56# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56]) +data Tuple56# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2 #) +type Tuple57# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57]) +data Tuple57# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2 #) +type Tuple58# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58]) +data Tuple58# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2 #) +type Tuple59# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59]) +data Tuple59# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2 #) +type Tuple60# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60]) +data Tuple60# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2 #) +type Tuple61# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61]) +data Tuple61# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2 #) +type Tuple62# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62]) +data Tuple62# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2 #) +type Tuple63# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63]) +data Tuple63# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2 #) +type Tuple64# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> + TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> + TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> + TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> + TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> + TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> + TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 -> TYPE r64 -> + TYPE (TupleRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, + r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, + r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64]) +data Tuple64# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 + r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2 = + (# a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1, + u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2 #) + +{- +Note [Unboxed sum with arity 64] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +While tuples are defined up to arity 64, sums can maximally have 63 alternatives. +This is due to the Unique layout for unboxed sums, which allots only six bits +for encoding the alternative. +-} + +type Sum2# :: TYPE r1 -> TYPE r2 -> TYPE (SumRep [r1, r2]) +data Sum2# a b = + (# a | #) + | (# | b #) + +type Sum3# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE (SumRep [r1, r2, r3]) +data Sum3# a b c = + (# a | | #) + | (# | b | #) + | (# | | c #) + +type Sum4# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE (SumRep [r1, r2, r3, r4]) +data Sum4# a b c d = + (# a | | | #) + | (# | b | | #) + | (# | | c | #) + | (# | | | d #) + +type Sum5# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE (SumRep [r1, r2, r3, r4, r5]) +data Sum5# a b c d e = + (# a | | | | #) + | (# | b | | | #) + | (# | | c | | #) + | (# | | | d | #) + | (# | | | | e #) + +type Sum6# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6]) +data Sum6# a b c d e f = + (# a | | | | | #) + | (# | b | | | | #) + | (# | | c | | | #) + | (# | | | d | | #) + | (# | | | | e | #) + | (# | | | | | f #) + +type Sum7# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7]) +data Sum7# a b c d e f g = + (# a | | | | | | #) + | (# | b | | | | | #) + | (# | | c | | | | #) + | (# | | | d | | | #) + | (# | | | | e | | #) + | (# | | | | | f | #) + | (# | | | | | | g #) + +type Sum8# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8]) +data Sum8# a b c d e f g h = + (# a | | | | | | | #) + | (# | b | | | | | | #) + | (# | | c | | | | | #) + | (# | | | d | | | | #) + | (# | | | | e | | | #) + | (# | | | | | f | | #) + | (# | | | | | | g | #) + | (# | | | | | | | h #) + +type Sum9# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9]) +data Sum9# a b c d e f g h i = + (# a | | | | | | | | #) + | (# | b | | | | | | | #) + | (# | | c | | | | | | #) + | (# | | | d | | | | | #) + | (# | | | | e | | | | #) + | (# | | | | | f | | | #) + | (# | | | | | | g | | #) + | (# | | | | | | | h | #) + | (# | | | | | | | | i #) + +type Sum10# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10]) +data Sum10# a b c d e f g h i j = + (# a | | | | | | | | | #) + | (# | b | | | | | | | | #) + | (# | | c | | | | | | | #) + | (# | | | d | | | | | | #) + | (# | | | | e | | | | | #) + | (# | | | | | f | | | | #) + | (# | | | | | | g | | | #) + | (# | | | | | | | h | | #) + | (# | | | | | | | | i | #) + | (# | | | | | | | | | j #) + +type Sum11# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11]) +data Sum11# a b c d e f g h i j k = + (# a | | | | | | | | | | #) + | (# | b | | | | | | | | | #) + | (# | | c | | | | | | | | #) + | (# | | | d | | | | | | | #) + | (# | | | | e | | | | | | #) + | (# | | | | | f | | | | | #) + | (# | | | | | | g | | | | #) + | (# | | | | | | | h | | | #) + | (# | | | | | | | | i | | #) + | (# | | | | | | | | | j | #) + | (# | | | | | | | | | | k #) + +type Sum12# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12]) +data Sum12# a b c d e f g h i j k l = + (# a | | | | | | | | | | | #) + | (# | b | | | | | | | | | | #) + | (# | | c | | | | | | | | | #) + | (# | | | d | | | | | | | | #) + | (# | | | | e | | | | | | | #) + | (# | | | | | f | | | | | | #) + | (# | | | | | | g | | | | | #) + | (# | | | | | | | h | | | | #) + | (# | | | | | | | | i | | | #) + | (# | | | | | | | | | j | | #) + | (# | | | | | | | | | | k | #) + | (# | | | | | | | | | | | l #) + +type Sum13# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13]) +data Sum13# a b c d e f g h i j k l m = + (# a | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | #) + | (# | | | d | | | | | | | | | #) + | (# | | | | e | | | | | | | | #) + | (# | | | | | f | | | | | | | #) + | (# | | | | | | g | | | | | | #) + | (# | | | | | | | h | | | | | #) + | (# | | | | | | | | i | | | | #) + | (# | | | | | | | | | j | | | #) + | (# | | | | | | | | | | k | | #) + | (# | | | | | | | | | | | l | #) + | (# | | | | | | | | | | | | m #) + +type Sum14# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14]) +data Sum14# a b c d e f g h i j k l m n = + (# a | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | #) + | (# | | | | | f | | | | | | | | #) + | (# | | | | | | g | | | | | | | #) + | (# | | | | | | | h | | | | | | #) + | (# | | | | | | | | i | | | | | #) + | (# | | | | | | | | | j | | | | #) + | (# | | | | | | | | | | k | | | #) + | (# | | | | | | | | | | | l | | #) + | (# | | | | | | | | | | | | m | #) + | (# | | | | | | | | | | | | | n #) + +type Sum15# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15]) +data Sum15# a b c d e f g h i j k l m n o = + (# a | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | #) + | (# | | | | | | | h | | | | | | | #) + | (# | | | | | | | | i | | | | | | #) + | (# | | | | | | | | | j | | | | | #) + | (# | | | | | | | | | | k | | | | #) + | (# | | | | | | | | | | | l | | | #) + | (# | | | | | | | | | | | | m | | #) + | (# | | | | | | | | | | | | | n | #) + | (# | | | | | | | | | | | | | | o #) + +type Sum16# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16]) +data Sum16# a b c d e f g h i j k l m n o p = + (# a | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | #) + | (# | | | | | | | | | j | | | | | | #) + | (# | | | | | | | | | | k | | | | | #) + | (# | | | | | | | | | | | l | | | | #) + | (# | | | | | | | | | | | | m | | | #) + | (# | | | | | | | | | | | | | n | | #) + | (# | | | | | | | | | | | | | | o | #) + | (# | | | | | | | | | | | | | | | p #) + +type Sum17# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17]) +data Sum17# a b c d e f g h i j k l m n o p q = + (# a | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | #) + | (# | | | | | | | | | | | l | | | | | #) + | (# | | | | | | | | | | | | m | | | | #) + | (# | | | | | | | | | | | | | n | | | #) + | (# | | | | | | | | | | | | | | o | | #) + | (# | | | | | | | | | | | | | | | p | #) + | (# | | | | | | | | | | | | | | | | q #) + +type Sum18# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18]) +data Sum18# a b c d e f g h i j k l m n o p q r = + (# a | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | #) + | (# | | | | | | | | | | | | | n | | | | #) + | (# | | | | | | | | | | | | | | o | | | #) + | (# | | | | | | | | | | | | | | | p | | #) + | (# | | | | | | | | | | | | | | | | q | #) + | (# | | | | | | | | | | | | | | | | | r #) + +type Sum19# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19]) +data Sum19# a b c d e f g h i j k l m n o p q r s = + (# a | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | #) + | (# | | | | | | | | | | | | | | | p | | | #) + | (# | | | | | | | | | | | | | | | | q | | #) + | (# | | | | | | | | | | | | | | | | | r | #) + | (# | | | | | | | | | | | | | | | | | | s #) + +type Sum20# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20]) +data Sum20# a b c d e f g h i j k l m n o p q r s t = + (# a | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | #) + | (# | | | | | | | | | | | | | | | | | r | | #) + | (# | | | | | | | | | | | | | | | | | | s | #) + | (# | | | | | | | | | | | | | | | | | | | t #) + +type Sum21# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21]) +data Sum21# a b c d e f g h i j k l m n o p q r s t u = + (# a | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | #) + | (# | | | | | | | | | | | | | | | | | | | t | #) + | (# | | | | | | | | | | | | | | | | | | | | u #) + +type Sum22# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22]) +data Sum22# a b c d e f g h i j k l m n o p q r s t u v = + (# a | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | #) + | (# | | | | | | | | | | | | | | | | | | | | | v #) + +type Sum23# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23]) +data Sum23# a b c d e f g h i j k l m n o p q r s t u v w = + (# a | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w #) + +type Sum24# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24]) +data Sum24# a b c d e f g h i j k l m n o p q r s t u v w x = + (# a | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x #) + +type Sum25# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25]) +data Sum25# a b c d e f g h i j k l m n o p q r s t u v w x y = + (# a | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y #) + +type Sum26# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26]) +data Sum26# a b c d e f g h i j k l m n o p q r s t u v w x y z = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z #) + +type Sum27# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27]) +data Sum27# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 #) + +type Sum28# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28]) +data Sum28# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 #) + +type Sum29# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29]) +data Sum29# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 #) + +type Sum30# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30]) +data Sum30# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 #) + +type Sum31# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31]) +data Sum31# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 #) + +type Sum32# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32]) +data Sum32# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 #) + +type Sum33# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33]) +data Sum33# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 #) + +type Sum34# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34]) +data Sum34# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 #) + +type Sum35# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35]) +data Sum35# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 #) + +type Sum36# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36]) +data Sum36# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 #) + +type Sum37# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37]) +data Sum37# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 #) + +type Sum38# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38]) +data Sum38# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 #) + +type Sum39# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39]) +data Sum39# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 #) + +type Sum40# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40]) +data Sum40# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 #) + +type Sum41# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41]) +data Sum41# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 #) + +type Sum42# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42]) +data Sum42# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 #) + +type Sum43# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43]) +data Sum43# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 #) + +type Sum44# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44]) +data Sum44# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 #) + +type Sum45# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45]) +data Sum45# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 #) + +type Sum46# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46]) +data Sum46# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 #) + +type Sum47# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47]) +data Sum47# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 #) + +type Sum48# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48]) +data Sum48# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 #) + +type Sum49# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49]) +data Sum49# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 #) + +type Sum50# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50]) +data Sum50# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 #) + +type Sum51# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51]) +data Sum51# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 #) + +type Sum52# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52]) +data Sum52# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 #) + +type Sum53# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53]) +data Sum53# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 #) + +type Sum54# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54]) +data Sum54# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 #) + +type Sum55# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55]) +data Sum55# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 #) + +type Sum56# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56]) +data Sum56# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 #) + +type Sum57# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57]) +data Sum57# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 #) + +type Sum58# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58]) +data Sum58# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 #) + +type Sum59# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59]) +data Sum59# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 #) + +type Sum60# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60]) +data Sum60# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 #) + +type Sum61# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61]) +data Sum61# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 #) + +type Sum62# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62]) +data Sum62# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j2 #) + +type Sum63# :: TYPE r1 -> TYPE r2 -> TYPE r3 -> TYPE r4 -> TYPE r5 -> TYPE r6 -> TYPE r7 -> TYPE r8 -> TYPE r9 -> TYPE r10 -> TYPE r11 -> TYPE r12 -> TYPE r13 -> TYPE r14 -> TYPE r15 -> TYPE r16 -> TYPE r17 -> TYPE r18 -> TYPE r19 -> TYPE r20 -> TYPE r21 -> TYPE r22 -> TYPE r23 -> TYPE r24 -> TYPE r25 -> TYPE r26 -> TYPE r27 -> TYPE r28 -> TYPE r29 -> TYPE r30 -> TYPE r31 -> TYPE r32 -> TYPE r33 -> TYPE r34 -> TYPE r35 -> TYPE r36 -> TYPE r37 -> TYPE r38 -> TYPE r39 -> TYPE r40 -> TYPE r41 -> TYPE r42 -> TYPE r43 -> TYPE r44 -> TYPE r45 -> TYPE r46 -> TYPE r47 -> TYPE r48 -> TYPE r49 -> TYPE r50 -> TYPE r51 -> TYPE r52 -> TYPE r53 -> TYPE r54 -> TYPE r55 -> TYPE r56 -> TYPE r57 -> TYPE r58 -> TYPE r59 -> TYPE r60 -> TYPE r61 -> TYPE r62 -> TYPE r63 -> TYPE (SumRep [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63]) +data Sum63# a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1 r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 = + (# a | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | c | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | d | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | e | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | f | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | g | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | h | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | i | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | j | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | k | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | l | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | m | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | n | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | o | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | p | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | q | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | r | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | s | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | t | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | u | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | v | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | w | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | x | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | y | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | z | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | a1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | b1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | c1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i1 | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j1 | | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k1 | | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | l1 | | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | m1 | | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | n1 | | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | o1 | | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | p1 | | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | q1 | | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | r1 | | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s1 | | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | t1 | | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | u1 | | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | v1 | | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | w1 | | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | x1 | | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | y1 | | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | z1 | | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | a2 | | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | b2 | | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | c2 | | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | d2 | | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | e2 | | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | f2 | | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | g2 | | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | h2 | | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | i2 | | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | j2 | #) + | (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | k2 #) diff --git a/cbits/atomic.c b/cbits/atomic.c --- a/cbits/atomic.c +++ b/cbits/atomic.c @@ -33,14 +33,12 @@ return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 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); } -#endif // FetchSubByteArrayOp_Int @@ -65,14 +63,12 @@ return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 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); } -#endif // FetchAndByteArrayOp_Int @@ -97,20 +93,17 @@ return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 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); } -#endif // 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: // @@ -207,7 +200,6 @@ #endif } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val); StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val) @@ -218,7 +210,6 @@ CAS_NAND((volatile StgWord64 *) x, val); #endif } -#endif #pragma GCC diagnostic pop @@ -245,14 +236,12 @@ return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 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); } -#endif // FetchXorByteArrayOp_Int @@ -277,14 +266,12 @@ return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 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); } -#endif // CasByteArrayOp_Int @@ -292,31 +279,37 @@ StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap((volatile StgWord8 *) x, (StgWord8) old, (StgWord8) new); + StgWord8 expected = (StgWord8) old; + __atomic_compare_exchange_n((StgWord8 *) x, &expected, (StgWord8) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); + return expected; } extern StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new); StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap((volatile StgWord16 *) x, (StgWord16) old, (StgWord16) new); + StgWord16 expected = (StgWord16) old; + __atomic_compare_exchange_n((StgWord16 *) x, &expected, (StgWord16) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); + return expected; } extern StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new); StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap((volatile StgWord32 *) x, (StgWord32) old, (StgWord32) new); + StgWord32 expected = (StgWord32) old; + __atomic_compare_exchange_n((StgWord32 *) x, &expected, (StgWord32) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); + return expected; } -#if WORD_SIZE_IN_BITS == 64 -extern StgWord hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new); -StgWord +extern StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new); +StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new) { - return __sync_val_compare_and_swap((volatile StgWord64 *) x, old, new); + StgWord64 expected = (StgWord64) old; + __atomic_compare_exchange_n((StgWord64 *) x, &expected, (StgWord64) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); + return expected; } -#endif // Atomic exchange operations @@ -341,15 +334,13 @@ return (StgWord) __atomic_exchange_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST); } -#if WORD_SIZE_IN_BITS == 64 //GCC provides this even on 32bit, but StgWord is still 32 bits. -extern StgWord hs_xchg64(StgWord x, StgWord val); -StgWord -hs_xchg64(StgWord x, StgWord val) +extern StgWord64 hs_xchg64(StgWord x, StgWord64 val); +StgWord64 +hs_xchg64(StgWord x, StgWord64 val) { - return (StgWord) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST); + return (StgWord64) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST); } -#endif // AtomicReadByteArrayOp_Int // Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp) @@ -365,47 +356,29 @@ StgWord hs_atomicread8(StgWord x) { -#if HAVE_C11_ATOMICS return __atomic_load_n((StgWord8 *) x, __ATOMIC_SEQ_CST); -#else - return __sync_add_and_fetch((StgWord8 *) x, 0); -#endif } extern StgWord hs_atomicread16(StgWord x); StgWord hs_atomicread16(StgWord x) { -#if HAVE_C11_ATOMICS return __atomic_load_n((StgWord16 *) x, __ATOMIC_SEQ_CST); -#else - return __sync_add_and_fetch((StgWord16 *) x, 0); -#endif } extern StgWord hs_atomicread32(StgWord x); StgWord hs_atomicread32(StgWord x) { -#if HAVE_C11_ATOMICS return __atomic_load_n((StgWord32 *) x, __ATOMIC_SEQ_CST); -#else - return __sync_add_and_fetch((StgWord32 *) x, 0); -#endif } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomicread64(StgWord x); StgWord64 hs_atomicread64(StgWord x) { -#if HAVE_C11_ATOMICS return __atomic_load_n((StgWord64 *) x, __ATOMIC_SEQ_CST); -#else - return __sync_add_and_fetch((StgWord64 *) x, 0); -#endif } -#endif // AtomicWriteByteArrayOp_Int // Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp) @@ -415,46 +388,28 @@ void hs_atomicwrite8(StgWord x, StgWord val) { -#if HAVE_C11_ATOMICS __atomic_store_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST); -#else - while (!__sync_bool_compare_and_swap((StgWord8 *) x, *(StgWord8 *) x, (StgWord8) val)); -#endif } extern void hs_atomicwrite16(StgWord x, StgWord val); void hs_atomicwrite16(StgWord x, StgWord val) { -#if HAVE_C11_ATOMICS __atomic_store_n((StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST); -#else - while (!__sync_bool_compare_and_swap((StgWord16 *) x, *(StgWord16 *) x, (StgWord16) val)); -#endif } extern void hs_atomicwrite32(StgWord x, StgWord val); void hs_atomicwrite32(StgWord x, StgWord val) { -#if HAVE_C11_ATOMICS __atomic_store_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST); -#else - while (!__sync_bool_compare_and_swap((StgWord32 *) x, *(StgWord32 *) x, (StgWord32) val)); -#endif } -#if WORD_SIZE_IN_BITS == 64 extern void hs_atomicwrite64(StgWord x, StgWord64 val); void hs_atomicwrite64(StgWord x, StgWord64 val) { -#if HAVE_C11_ATOMICS __atomic_store_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST); -#else - while (!__sync_bool_compare_and_swap((StgWord64 *) x, *(StgWord64 *) x, (StgWord64) val)); -#endif } -#endif #endif diff --git a/cbits/bitrev.c b/cbits/bitrev.c --- a/cbits/bitrev.c +++ b/cbits/bitrev.c @@ -3,7 +3,6 @@ /* 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) diff --git a/cbits/longlong.c b/cbits/longlong.c --- a/cbits/longlong.c +++ b/cbits/longlong.c @@ -79,9 +79,7 @@ HsInt64 hs_intToInt64 (HsInt i) {return (HsInt64) i;} HsInt hs_int64ToInt (HsInt64 i) {return (HsInt) i;} -HsWord64 hs_int64ToWord64 (HsInt64 i) {return (HsWord64) i;} HsWord64 hs_wordToWord64 (HsWord w) {return (HsWord64) w;} HsWord hs_word64ToWord (HsWord64 w) {return (HsWord) w;} -HsInt64 hs_word64ToInt64 (HsWord64 w) {return (HsInt64) w;} #endif /* SUPPORT_LONG_LONGS */ diff --git a/cbits/mulIntMayOflo.c b/cbits/mulIntMayOflo.c new file mode 100644 --- /dev/null +++ b/cbits/mulIntMayOflo.c @@ -0,0 +1,3 @@ +#include "Rts.h" + +W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); } diff --git a/changelog.md b/changelog.md --- a/changelog.md +++ b/changelog.md @@ -1,7 +1,379 @@ -## 0.8.0 +## 0.13.0 -- Shipped with GHC 9.2.1 +- Shipped with GHC 9.12.1 +- Add primops that allow users to distinguish weakly pinned byte arrays from unpinned ones. + + isMutableByteArrayWeaklyPinned# :: MutableByteArray# s -> Int# + isByteArrayWeaklyPinned# :: ByteArray# s -> Int# + +## 0.12.0 + +- Shipped with GHC 9.10.1 + +- Add unaligned addr access primops. These primops will be emulated on platforms that don't support unaligned access. + + readWord8OffAddrAsChar# :: Addr# -> Int# -> State# s -> (# State# s, Char# #) + readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# s -> (# State# s, Addr# #) + readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# s -> (# State# s, Float# #) + readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# s -> (# State# s, Double# #) + readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# s -> (# State# s, StablePtr# #) + readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# s -> (# State# s, Int16# #) + readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# s -> (# State# s, Int32# #) + readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# s -> (# State# s, Int64# #) + readWord8OffAddrAsInt# :: Addr# -> Int# -> State# s -> (# State# s, Int# #) + + readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# s -> (# State# s, Word16# #) + readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# s -> (# State# s, Word32# #) + readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# s -> (# State# s, Word64# #) + readWord8OffAddrAsWord# :: Addr# -> Int# -> State# s -> (# State# s, Word# #) + + indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char# + indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# + indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# + indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# + indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# + indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# + indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# + indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# + indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int# + + indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# + indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# + indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# + indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word# + + writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# s -> State# s + writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s + writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# s -> State# s + writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# s -> State# s + writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# -> State# s -> State# s + + writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# s -> State# s + writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# s -> State# s + writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# s -> State# s + writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# s -> State# s + + writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# s -> State# s + writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# s -> State# s + writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# s -> State# s + writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# s -> State# s + +- The `unsafeThawByteArray#` primop was added, serving as a inverse to the existing + `unsafeFreezeByteArray#` primop (see #22710). + +- `dataToTag#` has been moved to `GHC.Magic` and made the sole method + of a new class: + + ```haskell + type DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint + class DataToTag a where + dataToTag# :: a -> Int# + ``` + + In particular, it is now applicable only at some (not all) + lifted types. However, if `t` is an algebraic data type (i.e. `t` + matches a `data` or `data instance` declaration) with all of its + constructors in scope and the levity of `t` is statically known, + then the constraint `DataToTag t` can always be solved. + +- Renamed several built-in tycon syntaxes to avoid punning: + + - Unboxed tuple tycons are now `Tuple#` + - Unboxed sum tycons are now `Sum#` + - Constraint tuple classes are now `CTuple` + - Unit tycons are now `Unit#`, `CUnit`. + - Solo tycons are now `Solo#`, `CSolo`. + - `Tuple` have been moved back to `GHC.Tuple`. + + See [https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0475-tuple-syntax.rst]. + +## 0.11.0 + +- Shipped with GHC 9.8.1 + +- Primitive pointer comparison functions are now levity-polymorphic, e.g. + + ```haskell + sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int# + ``` + + This change affects the following functions: + - `sameArray#`, `sameMutableArray#`, + - `sameSmallArray#`, `sameSmallMutableArray#`, + - `sameMutVar#`, `sameTVar#`, `sameMVar#` + - `sameIOPort#`, `eqStableName#`. + +- `keepAlive#` and `touch#` are now polymorphic in their state token (#23163; [CLC#152](https://github.com/haskell/core-libraries-committee/issues/152)) + +- Several new primops were added: + + - `copyMutableByteArrayNonOverlapping#` + - `copyAddrToAddr#` + - `copyAddrToAddrNonOverlapping#` + - `setAddrRange#` + +- New primops for fused multiply-add operations. These primops combine a + multiplication and an addition, compiling to a single instruction when + the `-mfma` flag is enabled and the architecture supports it. + + The new primops are `fmaddFloat#, fmsubFloat#, fnmaddFloat#, fnmsubFloat# :: Float# -> Float# -> Float# -> Float#` + and `fmaddDouble#, fmsubDouble#, fnmaddDouble#, fnmsubDouble# :: Double# -> Double# -> Double# -> Double#`. + + These implement the following operations, while performing one single + rounding at the end, leading to a more accurate result: + + - `fmaddFloat# x y z`, `fmaddDouble# x y z` compute `x * y + z`. + - `fmsubFloat# x y z`, `fmsubDouble# x y z` compute `x * y - z`. + - `fnmaddFloat# x y z`, `fnmaddDouble# x y z` compute `- x * y + z`. + - `fnmsubFloat# x y z`, `fnmsubDouble# x y z` compute `- x * y - z`. + + Warning: on unsupported architectures, the software emulation provided by + the fallback to the C standard library is not guaranteed to be IEEE-compliant. + +- `Unit`, `Tuple0`, `Tuple1`, `Tuple2`, `Tuple3` and so on (up to `Tuple64`) + are now exported from `GHC.Tuple.Prim` and reexported from `GHC.Tuple`. + GHC now uses these as the actual names for tuple data types. As a result, + the "brackets with commas" syntax (e.g. `()`, `(,)`, etc.) now becomes just + an alias to these names. This change may affect tools and libraries that + rely on type names, such as `Generic` and Template Haskell. + +## 0.10.0 + +- Shipped with GHC 9.6.1 + +- The `listThreads#` primop was added, allowing the user to enumerate all + threads (running and blocked) in the program: + ```haskell + listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #) + ``` + +- The type of the `labelThread#` primop was changed from: + ```haskell + labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld + ``` + to + ```haskell + labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld + ``` + Where the `ByteArray#` must contain a UTF-8-encoded string. + +- The `threadLabel#` primop was added, allowing the user to query the label of + a given `ThreadId#`. + +- `isByteArrayPinned#` now only considers an array pinned if it was explicitly pinned + by the user. This is required to avoid ghc issue [#22255](https://gitlab.haskell.org/ghc/ghc/-/issues/22255) + which showed that the old behaviour could cause segfaults when used in combination + with compact regions. + We are working on ways to allow users and library authors to get back the + performance benefits of the old behaviour where possible. + +- `List` is now exported from `GHC.Types`. + +## 0.9.0 *August 2022* + +- Shipped with GHC 9.4.1 + +- `magicDict` has been renamed to `withDict` and is now defined in + `GHC.Magic.Dict` instead of `GHC.Prim`. `withDict` now has the type: + + ```haskell + withDict :: forall {rr :: RuntimeRep} st dt (r :: TYPE rr). st -> (dt => r) -> r + ``` + + Unlike `magicDict`, `withDict` can be used without defining an + intermediate data type. For example, the `withTypeable` function from the + `Data.Typeable` module can now be defined as: + + ```haskell + withTypeable :: forall k (a :: k) rep (r :: TYPE rep). () + => TypeRep a -> (Typeable a => r) -> r + withTypeable rep k = withDict @(TypeRep a) @(Typeable a) rep k + ``` + + Note that the explicit type applications are required, as the call to + `withDict` would be ambiguous otherwise. + +- Primitive types and functions which handle boxed values are now levity-polymorphic, + meaning that they now also work with unlifted boxed values (i.e. values whose type + has kind `TYPE (BoxedRep Unlifted)`). + + The following type constructors are now levity-polymorphic: + + - `Array#`, `SmallArray#`, `Weak#`, `StablePtr#`, `StableName#`, + + - `MutableArray#`, `SmallMutableArray#`, `MutVar#`, + `TVar#`, `MVar#`, `IOPort#`. + + For example, `Array#` used to have kind: + + ```haskell + Type -> UnliftedType + ``` + + but it now has kind: + + ```haskell + forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType + ``` + + Similarly, `MutVar#` used to have kind: + + ```haskell + Type -> Type -> UnliftedType + ``` + + but it now has kind: + + ```haskell + forall {l :: Levity}. Type -> TYPE (BoxedRep l) -> UnliftedType + ``` + + This means that in `Array# a`, `MutableArray# s a`, `MutVar# s a`, ..., + the element type `a`, must always be boxed, but it can now either be lifted + or unlifted. + In particular, arrays and mutable variables can now be used to store + other arrays and mutable variables. + + All functions which use these updated primitive types are also levity-polymorphic: + + - all array operations (reading/writing/copying/...), for both arrays and small arrays, + mutable and immutable: + + - `newArray#`, `readArray#`, `writeArray#`, `sizeofArray#`, `sizeofMutableArray#`, `indexArray#`, + `unsafeFreezeArray#`, `unsafeThawArray#`, `copyArray#`, `copyMutableArray#`, `cloneArray#`, + `cloneMutableArray#`, `freezeArray#`, `thawArray#`, `casArray#`, + + - `newSmallArray#`, `shrinkSmallMutableArray#`, `readSmallArray#`, `writeSmallArray#`, `sizeofSmallArray#`, + `getSizeofSmallMutableArray#`, `indexSmallArray#`, `unsafeFreezeSmallArray#`, + `unsafeThawSmallArray#`, `copySmallArray#`, `copySmallMutableArray#`, `cloneSmallArray#`, + `cloneSmallMutableArray#`, `freezeSmallArray#`, `thawSmallArray#`, `casSmallArray#`, + + - `newMutVar#`, `readMutVar#`, `writeMutVar#`,`casMutVar#`, + + - operations on `MVar#` and `TVar#`: + + - `newTVar#`, `readTVar#`, `readTVarIO#`, `writeTVar#`, + + - `newMVar#`, `takeMVar#`, `tryTakeMVar#`, `putMVar#`, + `tryPutMVar#`, `readMVar#`, `tryReadMVar#`, + + - `STM` operations `atomically#`, `retry#`, `catchRetry#` and `catchSTM#`. + + - `newIOPort#`, `readIOPort#`, `writeIOPort#`, + + - `mkWeak#`, `mkWeakNoFinalizer#`, `addCFinalizerToWeak#`, `deRefWeak#`, `finalizeWeak#`, + + - `makeStablePtr#`, `deRefStablePtr#`, `eqStablePtr#`, `makeStableName#`, `stableNameToInt#`, + + For example, the full type of `newMutVar#` is now: + + ```haskell + newMutVar# + :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). + a -> State# s -> (# State# s, MVar# s a #) + ``` + + and the full type of `writeSmallArray#` is: + + ```haskell + writeSmallArray# + :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). + SmallMutableArray# s a -> Int# -> a -> State# s -> State# s + ``` + +- `ArrayArray#` and `MutableArrayArray#` have been moved from `GHC.Prim` to `GHC.Exts`. + They are deprecated, because their functionality is now subsumed by `Array#` + and `MutableArray#`. + +- `mkWeak#`, `mkWeakNoFinalizer#`, `touch#` and `keepAlive#` are now + levity-polymorphic instead of representation-polymorphic. For instance: + + ```haskell + mkWeakNoFinalizer# + :: forall {l :: Levity} {k :: Levity} + (a :: TYPE ('BoxedRep l)) + (b :: TYPE ('BoxedRep k)). + a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #) + ``` + + That is, the type signature now quantifies over the `Levity` of `a` + instead of its `RuntimeRep`. In addition, this variable is now inferred, + instead of specified, meaning that it is no longer eligible for visible type application. + Note that `b` is now also levity-polymorphic, due to the change outlined in the + previous point. + +- Primitive functions for throwing and catching exceptions are now more polymorphic + than before. For example, `catch#` now has type: + + ```haskell + catch# + :: forall {r :: RuntimeRep} {l :: Levity} + (a :: TYPE r) + (b :: TYPE ('BoxedRep l)). + ( State# RealWorld -> (# State# RealWorld, a #) ) + -> ( b -> State# RealWorld -> (# State# RealWorld, a #) ) + -> State# RealWorld -> (# State# RealWorld, a #) + ``` + + The following functions are concerned: + + - `catch#`, + + - `raise#`, `raiseIO#`, + + - `maskAsyncExceptions#`, `maskUninterruptible#`, `unmaskAsyncExceptions#`. + + Note in particular that `raise#` is now both representation-polymorphic + (with an inferred `RuntimeRep` argument) and levity-polymorphic, with type: + + ```haskell + raise# :: forall {l :: Levity} {r :: RuntimeRep} + (a :: TYPE (BoxedRep l)) + (b :: TYPE r). + a -> b + ``` + +- ``fork#`` and ``forkOn#`` are now representation-polymorphic. For example, ``fork#`` + now has type: :: + + fork# :: forall {r :: RuntimeRep} (a :: TYPE r). + (State# RealWorld -> (# State# RealWorld, a #)) + -> (State# RealWorld -> (# State# RealWorld, a #)) + +- `reallyUnsafePtrEquality#` has been made more general, as it is now + both levity-polymorphic and heterogeneous: + + ```haskell + reallyUnsafePtrEquality# + :: forall {l :: Levity} {k :: Levity} + (a :: TYPE (BoxedRep l)) + (b :: TYPE (BoxedRep k)) + . a -> b -> Int# + ``` + + This means that `reallyUnsafePtrEquality#` can be used on primitive arrays + such as `Array#` and `ByteArray#`. It can also be used on values of + different types, without needing to call `unsafeCoerce#`. + +- The following functions have been moved from `GHC.Prim` to `GHC.Exts`: + - `sameMutableArray#`, `sameSmallMutableArray#`, `sameMutableByteArray#` + and `sameMutableArrayArray#`, + - `sameMutVar#`, `sameTVar#` and`sameMVar#`, + - `sameIOPort#`, + - `eqStableName#`. + +- The following functions have been added to `GHC.Exts`: + + ```haskell + sameArray# :: Array# a -> Array# a -> Int# + sameSmallArray# :: SmallArray# a -> SmallArray# a -> Int# + sameByteArray# :: ByteArray# -> ByteArray# -> Int# + sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int# + ``` + +## 0.8.0 + - Change array access primops to use type with size maxing the element size: - `index{Int,Word}Array# :: ByteArray# -> Int# -> {Int,Word}#` @@ -18,6 +390,17 @@ - `extend{Int,Word}#` -> `extendTo{Int,Word}#` - `narrow{Int,Word}#` -> `intTo{Int,Word}#` +- Add primops for atomic compare and swap for sizes other that wordsize: + + casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s, Int8# #) + casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s, Int16# #) + casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s, Int32# #) + casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s, Int64# #) + atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s, Word8# #) + atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s, Word16# #) + atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s, Word32# #) + atomicCasWord64Addr# :: Addr# -> WORD64 -> WORD64 -> State# s -> (# State# s, WORD64 #) + ## 0.7.0 - Shipped with GHC 9.0.1 @@ -25,7 +408,7 @@ - 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: @@ -49,7 +432,7 @@ atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s, Addr# #) atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s, Word# #) -- Add an explicit fixity for `(~)` and `(~~)`: +- Add an explicit fixity for `(~)` and `(~~)`: infix 4 ~, ~~ @@ -57,7 +440,7 @@ the soundness issues of the latter (see [#17760](https://gitlab.haskell.org/ghc/ghc/-/issues/17760)). -## 0.6.1 (edit as necessary) +## 0.6.1 - Shipped with GHC 8.10.1 diff --git a/ghc-prim.cabal b/ghc-prim.cabal --- a/ghc-prim.cabal +++ b/ghc-prim.cabal @@ -1,6 +1,6 @@ cabal-version: 2.2 name: ghc-prim -version: 0.8.0 +version: 0.13.0 -- NOTE: Don't forget to update ./changelog.md license: BSD-3-Clause license-file: LICENSE @@ -12,6 +12,11 @@ description: 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 @@ -20,8 +25,11 @@ subdir: libraries/ghc-prim custom-setup - setup-depends: base >= 4 && < 5, Cabal >= 1.23 + setup-depends: base >= 4 && < 5, process, filepath, directory, Cabal >= 1.23 && < 3.9 +flag need-atomic + default: False + Library default-language: Haskell2010 other-extensions: @@ -44,9 +52,11 @@ GHC.Classes GHC.Debug GHC.Magic + GHC.Magic.Dict GHC.Prim.Ext GHC.Prim.Panic GHC.Prim.Exception + GHC.Prim.PtrEq GHC.PrimopWrappers GHC.Tuple GHC.Types @@ -58,33 +68,39 @@ if os(windows) -- Windows requires some extra libraries for linking because the RTS -- is no longer re-exporting them (see #11223) - -- msvcrt: standard C library. The RTS will automatically include this, - -- but is added for completeness. - -- mingwex: provides C99 compatibility. libm is a stub on MingW. + -- 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 + extra-libraries: user32, mingw32, mingwex, ucrt 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 - c-sources: - cbits/atomic.c - cbits/bswap.c - cbits/bitrev.c - cbits/clz.c - cbits/ctz.c - cbits/debug.c - cbits/longlong.c - cbits/pdep.c - cbits/pext.c - cbits/popcnt.c - cbits/word2float.c + 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.