ghc-prim 0.7.0 → 0.8.0

raw patch · 12 files changed

+526/−311 lines, 12 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• GHC/Classes.hs +30/−14
• GHC/IntWord64.hs +0/−74
• GHC/Magic.hs +2/−15
• GHC/Prim/Exception.hs +3/−3
• GHC/Prim/Ext.hs +1/−1
• GHC/Prim/Panic.hs +60/−2
• GHC/PrimopWrappers.hs +307/−97
• GHC/Tuple.hs +64/−79
• GHC/Types.hs +25/−9
• cbits/longlong.c +9/−11
• changelog.md +24/−4
• ghc-prim.cabal +1/−2

@@ -55,7 +55,6 @@  -- GHC.Magic is used in some derived instances import GHC.Magic ()-import GHC.IntWord64 import GHC.Prim import GHC.Tuple import GHC.CString (unpackCString#)@@ -125,18 +124,13 @@ -- and 'Eq' may be derived for any datatype whose constituents are also -- instances of 'Eq'. ----- The Haskell Report defines no laws for 'Eq'. However, '==' is customarily--- expected to implement an equivalence relationship where two values comparing--- equal are indistinguishable by "public" functions, with a "public" function--- being one not allowing to see implementation details. For example, for a--- type representing non-normalised natural numbers modulo 100, a "public"--- function doesn't make the difference between 1 and 201. It is expected to--- have the following properties:+-- 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'--- [__Substitutivity__]: if @x == y@ = 'True' and @f@ is a "public" function+-- [__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)@ --@@ -152,6 +146,7 @@     {-# 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)@@ -234,7 +229,7 @@ -- >>> 0/0 == (0/0 :: Float) -- False ----- Also note that `Float`'s 'Eq' instance does not satisfy substitutivity:+-- Also note that `Float`'s 'Eq' instance does not satisfy extensionality: -- -- >>> 0 == (-0 :: Float) -- True@@ -312,15 +307,15 @@ -- 'Ordering' datatype allows a single comparison to determine the precise -- ordering of two objects. ----- The Haskell Report defines no laws for 'Ord'. However, '<=' is customarily--- expected to implement a non-strict partial order and have the following--- properties:+-- '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' ----- Note that the following operator interactions are expected to hold:+-- The following operator interactions are expected to hold: -- -- 1. @x >= y@ = @y <= x@ -- 2. @x < y@ = @x <= y && x /= y@@@ -362,6 +357,7 @@     {-# 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)@@ -890,3 +886,23 @@        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)

@@ -1,74 +0,0 @@-{-# LANGUAGE CPP, MagicHash, NoImplicitPrelude, UnliftedFFITypes #-}-{-# OPTIONS_HADDOCK not-home #-}--------------------------------------------------------------------------------- |--- Module      :  GHC.IntWord64--- Copyright   :  (c) The University of Glasgow, 1997-2008--- License     :  see libraries/ghc-prim/LICENSE------ Maintainer  :  cvs-ghc@haskell.org--- Stability   :  internal--- Portability :  non-portable (GHC Extensions)------ Primitive operations on Int64# and Word64# on platforms where--- WORD_SIZE_IN_BITS < 64.-----------------------------------------------------------------------------------#include "MachDeps.h"--module GHC.IntWord64 (-#if WORD_SIZE_IN_BITS < 64-        Int64#, Word64#, module GHC.IntWord64-#endif-    ) where--import GHC.Types () -- Make implicit dependency known to build system--#if WORD_SIZE_IN_BITS < 64--import GHC.Prim--foreign import ccall unsafe "hs_eqWord64"    eqWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_neWord64"    neWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_ltWord64"    ltWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_leWord64"    leWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_gtWord64"    gtWord64#     :: Word64# -> Word64# -> Int#-foreign import ccall unsafe "hs_geWord64"    geWord64#     :: Word64# -> Word64# -> Int#--foreign import ccall unsafe "hs_eqInt64"     eqInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_neInt64"     neInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_ltInt64"     ltInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_leInt64"     leInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_gtInt64"     gtInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_geInt64"     geInt64#      :: Int64# -> Int64# -> Int#-foreign import ccall unsafe "hs_quotInt64"   quotInt64#    :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_remInt64"    remInt64#     :: Int64# -> Int64# -> Int64#--foreign import ccall unsafe "hs_plusInt64"   plusInt64#    :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_minusInt64"  minusInt64#   :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_timesInt64"  timesInt64#   :: Int64# -> Int64# -> Int64#-foreign import ccall unsafe "hs_negateInt64" negateInt64#  :: Int64# -> Int64#-foreign import ccall unsafe "hs_quotWord64"  quotWord64#   :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_remWord64"   remWord64#    :: Word64# -> Word64# -> Word64#--foreign import ccall unsafe "hs_and64"       and64#        :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_or64"        or64#         :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_xor64"       xor64#        :: Word64# -> Word64# -> Word64#-foreign import ccall unsafe "hs_not64"       not64#        :: Word64# -> Word64#--foreign import ccall unsafe "hs_uncheckedShiftL64"   uncheckedShiftL64#   :: Word64# -> Int# -> Word64#-foreign import ccall unsafe "hs_uncheckedShiftRL64"  uncheckedShiftRL64#  :: Word64# -> Int# -> Word64#-foreign import ccall unsafe "hs_uncheckedIShiftL64"  uncheckedIShiftL64#  :: Int64# -> Int# -> Int64#-foreign import ccall unsafe "hs_uncheckedIShiftRA64" uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#-foreign import ccall unsafe "hs_uncheckedIShiftRL64" uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#--foreign import ccall unsafe "hs_int64ToWord64"   int64ToWord64#   :: Int64# -> Word64#-foreign import ccall unsafe "hs_word64ToInt64"   word64ToInt64#   :: Word64# -> Int64#-foreign import ccall unsafe "hs_intToInt64"      intToInt64#      :: Int# -> Int64#-foreign import ccall unsafe "hs_int64ToInt"      int64ToInt#      :: Int64# -> Int#-foreign import ccall unsafe "hs_wordToWord64"    wordToWord64#    :: Word# -> Word64#-foreign import ccall unsafe "hs_word64ToWord"    word64ToWord#    :: Word64# -> Word#--#endif-

@@ -1,8 +1,6 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE MagicHash #-}-{-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-}@@ -32,13 +30,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.--- Likewise, realWorld# is not generated by genprimops so we use CPP and only--- import/use it when not building haddock docs.-#if !defined(__HADDOCK_VERSION__)-import GHC.Prim (realWorld#)-#endif-import GHC.Prim (State#, RealWorld)+-- genprimops which Haddock will typecheck (#15935).+import GHC.Prim (State#, realWorld#, RealWorld) import GHC.Types (RuntimeRep, TYPE)  -- | The call @inline f@ arranges that @f@ is inlined, regardless of@@ -83,8 +76,6 @@ -- -- If 'lazy' were not lazy, 'Control.Parallel.par' would look strict in -- @y@ which would defeat the whole purpose of 'Control.Parallel.par'.------ Like 'seq', the argument of 'lazy' can have an unboxed type. lazy :: a -> a lazy x = x -- Implementation note: its strictness and unfolding are over-ridden@@ -124,8 +115,4 @@           (State# RealWorld -> o) -> o -- See Note [runRW magic] in GHC.CoreToStg.Prep. {-# NOINLINE runRW# #-}  -- runRW# is inlined manually in CorePrep-#if !defined(__HADDOCK_VERSION__) runRW# m = m realWorld#-#else-runRW# = runRW#   -- The realWorld# is too much for haddock-#endif

@@ -28,9 +28,9 @@ -- 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, Void# #)-foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, Void# #)-foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, Void# #)+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

@@ -10,7 +10,7 @@ #include "MachDeps.h"  -- See note [When do out-of-line primops go in primops.txt.pp]. More primops--- there are elgible according to the description below, but cannot yet be moved+-- there are eligible according to the description below, but cannot yet be moved -- here because of superficial restrictions to `foreign import prim`. Hopefully -- that is fixed soon. 

@@ -9,6 +9,7 @@ module GHC.Prim.Panic    ( absentSumFieldError    , panicError+   , absentError    ) where @@ -17,10 +18,56 @@  default () -- Double and Integer aren't available yet +{-+Note [Compiler error functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Most error functions (such as pattern match failure) are defined+in base:Control.Exception.Base.  But absentError# and absentSumFieldError#+are defined here in the ghc-prim package for two reasons:++* GHC itself generates calls to these functions as a result of+  strictness analysis, over which the programmer has no control. So+  it is hard to ensure that no such calls exist in the modules+  compiled "before" Control.Base.Exception.  (E.g. when compiling+  with -fdicts-strict.)++* A consequence of defining them in ghc-prim is that the libraries+  defining exceptions have not yet been built, so we can't make them+  into proper Haskell exceptions.++  However, if these functions are ever called, it's a /compiler/ error,+  not a user error, so it seems acceptable that they cannot be caught.++One might wonder why absentError doesn't just call panic#.+For absent error we want to combine two parts, one static, one call site+dependent into one error message. While for absentSumFieldError it's a+static string.++The easiest way to combine the two parts for absentError is to use a+format string with `barf` in the RTS passing the *dynamic* part of the+error as argument. There is no need to do any of this for+absentSumFieldError as it's a static string there.++The alternatives would be to:+* Drop the call site specific information from absentError.+  The call site specific information is at times very helpful for debugging+  so I don't consider this an option.+* Remove the common prefix. We would then need to include the prefix+  in the call site specific string we pass to absentError. Increasing+  code size for no good reason.++Both of which seem worse than having an stg_absentError function specific to+absentError to me.+-}+ -- `stg_panic#` never returns but it can't just return `State# RealWorld` so we--- indicate that it returns `Void#` too to make the compiler happy.-foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, Void# #)+-- indicate that it returns `(# #)` too to make the compiler happy.+-- See Note [Compiler error functions]+foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, (# #) #) +-- See Note [Compiler error functions]+foreign import prim "stg_absentErrorzh" stg_absentError# :: Addr# -> State# RealWorld -> (# State# RealWorld, (# #) #)+ -- | Display the CString whose address is given as an argument and exit. panicError :: Addr# -> a panicError errmsg =@@ -43,3 +90,14 @@ -- introduced in Stg.Unarise, long after inlining has stopped, but it seems -- more direct simply to give it a NOINLINE pragma {-# NOINLINE absentSumFieldError #-}++-- | Displays "Oops!  Entered absent arg" ++ errormsg and exits the program.+{-# NOINLINE absentError #-}+absentError :: Addr# -> a+absentError errmsg =+  runRW# (\s ->+    case stg_absentError# errmsg s of+      (# _, _ #) -> -- This bottom is unreachable but we can't+                    -- use an empty case lest the pattern match+                    -- checker squawks.+                    let x = x in x)

@@ -3,7 +3,7 @@ module GHC.PrimopWrappers where import qualified GHC.Prim import GHC.Tuple ()-import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO)+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@@ -25,12 +25,12 @@ {-# NOINLINE ord# #-} ord# :: Char# -> Int# ord# a1 = (GHC.Prim.ord#) a1-{-# NOINLINE extendInt8# #-}-extendInt8# :: Int8# -> Int#-extendInt8# a1 = (GHC.Prim.extendInt8#) a1-{-# NOINLINE narrowInt8# #-}-narrowInt8# :: Int# -> Int8#-narrowInt8# a1 = (GHC.Prim.narrowInt8#) 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@@ -52,6 +52,18 @@ {-# 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@@ -70,15 +82,12 @@ {-# NOINLINE neInt8# #-} neInt8# :: Int8# -> Int8# -> Int# neInt8# a1 a2 = (GHC.Prim.neInt8#) a1 a2-{-# NOINLINE extendWord8# #-}-extendWord8# :: Word8# -> Word#-extendWord8# a1 = (GHC.Prim.extendWord8#) a1-{-# NOINLINE narrowWord8# #-}-narrowWord8# :: Word# -> Word8#-narrowWord8# a1 = (GHC.Prim.narrowWord8#) a1-{-# NOINLINE notWord8# #-}-notWord8# :: Word8# -> Word8#-notWord8# a1 = (GHC.Prim.notWord8#) a1+{-# 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@@ -97,6 +106,27 @@ {-# 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@@ -115,12 +145,12 @@ {-# NOINLINE neWord8# #-} neWord8# :: Word8# -> Word8# -> Int# neWord8# a1 a2 = (GHC.Prim.neWord8#) a1 a2-{-# NOINLINE extendInt16# #-}-extendInt16# :: Int16# -> Int#-extendInt16# a1 = (GHC.Prim.extendInt16#) a1-{-# NOINLINE narrowInt16# #-}-narrowInt16# :: Int# -> Int16#-narrowInt16# a1 = (GHC.Prim.narrowInt16#) a1+{-# 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@@ -142,6 +172,18 @@ {-# 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@@ -160,15 +202,12 @@ {-# NOINLINE neInt16# #-} neInt16# :: Int16# -> Int16# -> Int# neInt16# a1 a2 = (GHC.Prim.neInt16#) a1 a2-{-# NOINLINE extendWord16# #-}-extendWord16# :: Word16# -> Word#-extendWord16# a1 = (GHC.Prim.extendWord16#) a1-{-# NOINLINE narrowWord16# #-}-narrowWord16# :: Word# -> Word16#-narrowWord16# a1 = (GHC.Prim.narrowWord16#) a1-{-# NOINLINE notWord16# #-}-notWord16# :: Word16# -> Word16#-notWord16# a1 = (GHC.Prim.notWord16#) a1+{-# 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@@ -187,6 +226,27 @@ {-# 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@@ -205,6 +265,126 @@ {-# 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@@ -808,6 +988,9 @@ {-# 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@@ -854,25 +1037,25 @@ indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a indexStablePtrArray# a1 a2 = (GHC.Prim.indexStablePtrArray#) a1 a2 {-# NOINLINE indexInt8Array# #-}-indexInt8Array# :: ByteArray# -> Int# -> Int#+indexInt8Array# :: ByteArray# -> Int# -> Int8# indexInt8Array# a1 a2 = (GHC.Prim.indexInt8Array#) a1 a2 {-# NOINLINE indexInt16Array# #-}-indexInt16Array# :: ByteArray# -> Int# -> Int#+indexInt16Array# :: ByteArray# -> Int# -> Int16# indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2 {-# NOINLINE indexInt32Array# #-}-indexInt32Array# :: ByteArray# -> Int# -> Int#+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# -> Word#+indexWord8Array# :: ByteArray# -> Int# -> Word8# indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2 {-# NOINLINE indexWord16Array# #-}-indexWord16Array# :: ByteArray# -> Int# -> Word#+indexWord16Array# :: ByteArray# -> Int# -> Word16# indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2 {-# NOINLINE indexWord32Array# #-}-indexWord32Array# :: ByteArray# -> Int# -> Word#+indexWord32Array# :: ByteArray# -> Int# -> Word32# indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2 {-# NOINLINE indexWord64Array# #-} indexWord64Array# :: ByteArray# -> Int# -> Word#@@ -883,6 +1066,12 @@ {-# 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@@ -896,29 +1085,23 @@ indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a indexWord8ArrayAsStablePtr# a1 a2 = (GHC.Prim.indexWord8ArrayAsStablePtr#) a1 a2 {-# NOINLINE indexWord8ArrayAsInt16# #-}-indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#+indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16# indexWord8ArrayAsInt16# a1 a2 = (GHC.Prim.indexWord8ArrayAsInt16#) a1 a2 {-# NOINLINE indexWord8ArrayAsInt32# #-}-indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#+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 indexWord8ArrayAsInt# #-}-indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#-indexWord8ArrayAsInt# a1 a2 = (GHC.Prim.indexWord8ArrayAsInt#) a1 a2 {-# NOINLINE indexWord8ArrayAsWord16# #-}-indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#+indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16# indexWord8ArrayAsWord16# a1 a2 = (GHC.Prim.indexWord8ArrayAsWord16#) a1 a2 {-# NOINLINE indexWord8ArrayAsWord32# #-}-indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#+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 indexWord8ArrayAsWord# #-}-indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#-indexWord8ArrayAsWord# a1 a2 = (GHC.Prim.indexWord8ArrayAsWord#) a1 a2 {-# NOINLINE readCharArray# #-} readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) readCharArray# a1 a2 a3 = (GHC.Prim.readCharArray#) a1 a2 a3@@ -944,25 +1127,25 @@ readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) readStablePtrArray# a1 a2 a3 = (GHC.Prim.readStablePtrArray#) a1 a2 a3 {-# NOINLINE readInt8Array# #-}-readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt8Array# :: 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,Int# #)+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,Int# #)+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,Word# #)+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,Word# #)+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,Word# #)+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# #)@@ -973,6 +1156,12 @@ {-# 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@@ -986,29 +1175,23 @@ 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,Int# #)+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,Int# #)+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 readWord8ArrayAsInt# #-}-readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readWord8ArrayAsInt# a1 a2 a3 = (GHC.Prim.readWord8ArrayAsInt#) a1 a2 a3 {-# NOINLINE readWord8ArrayAsWord16# #-}-readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+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,Word# #)+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 readWord8ArrayAsWord# #-}-readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord8ArrayAsWord# a1 a2 a3 = (GHC.Prim.readWord8ArrayAsWord#) 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@@ -1034,25 +1217,25 @@ writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s writeStablePtrArray# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrArray#) a1 a2 a3 a4 {-# NOINLINE writeInt8Array# #-}-writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt8Array# :: 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# -> Int# -> State# s -> State# s+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# -> Int# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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@@ -1063,6 +1246,12 @@ {-# 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@@ -1076,29 +1265,23 @@ 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# -> Int# -> State# s -> State# s+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# -> Int# -> State# s -> State# s+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 writeWord8ArrayAsInt# #-}-writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeWord8ArrayAsInt# a1 a2 a3 a4 = (GHC.Prim.writeWord8ArrayAsInt#) a1 a2 a3 a4 {-# NOINLINE writeWord8ArrayAsWord16# #-}-writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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 writeWord8ArrayAsWord# #-}-writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord8ArrayAsWord# a1 a2 a3 a4 = (GHC.Prim.writeWord8ArrayAsWord#) 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@@ -1256,25 +1439,25 @@ indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2 {-# NOINLINE indexInt8OffAddr# #-}-indexInt8OffAddr# :: Addr# -> Int# -> Int#+indexInt8OffAddr# :: Addr# -> Int# -> Int8# indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2 {-# NOINLINE indexInt16OffAddr# #-}-indexInt16OffAddr# :: Addr# -> Int# -> Int#+indexInt16OffAddr# :: Addr# -> Int# -> Int16# indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2 {-# NOINLINE indexInt32OffAddr# #-}-indexInt32OffAddr# :: Addr# -> Int# -> Int#+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# -> Word#+indexWord8OffAddr# :: Addr# -> Int# -> Word8# indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2 {-# NOINLINE indexWord16OffAddr# #-}-indexWord16OffAddr# :: Addr# -> Int# -> Word#+indexWord16OffAddr# :: Addr# -> Int# -> Word16# indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2 {-# NOINLINE indexWord32OffAddr# #-}-indexWord32OffAddr# :: Addr# -> Int# -> Word#+indexWord32OffAddr# :: Addr# -> Int# -> Word32# indexWord32OffAddr# a1 a2 = (GHC.Prim.indexWord32OffAddr#) a1 a2 {-# NOINLINE indexWord64OffAddr# #-} indexWord64OffAddr# :: Addr# -> Int# -> Word#@@ -1304,25 +1487,25 @@ readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) readStablePtrOffAddr# a1 a2 a3 = (GHC.Prim.readStablePtrOffAddr#) a1 a2 a3 {-# NOINLINE readInt8OffAddr# #-}-readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt8OffAddr# :: 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,Int# #)+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,Int# #)+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,Word# #)+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,Word# #)+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,Word# #)+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# #)@@ -1352,25 +1535,25 @@ writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s writeStablePtrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrOffAddr#) a1 a2 a3 a4 {-# NOINLINE writeInt8OffAddr# #-}-writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# s -> State# s writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) a1 a2 a3 a4 {-# NOINLINE writeInt16OffAddr# #-}-writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s writeInt16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt16OffAddr#) a1 a2 a3 a4 {-# NOINLINE writeInt32OffAddr# #-}-writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt32OffAddr# :: 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# -> Word# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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# -> Word# -> State# s -> State# s+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@@ -1387,6 +1570,30 @@ {-# 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@@ -1654,6 +1861,9 @@ {-# 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

@@ -29,8 +29,64 @@ -- The desugarer uses 1-tuples, -- but "()" 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).+--+-- The most important feature of @Solo@ is that it is possible to force its+-- "outside" (usually by pattern matching) without forcing its "inside",+-- because it is defined as a datatype rather than a newtype. One situation+-- where this can be useful is when writing a function to extract a value from+-- a data structure. Suppose you write an implementation of arrays and offer+-- only this function to index into them:+--+-- @+-- index :: Array a -> Int -> a+-- @+--+-- Now imagine that someone wants to extract a value from an array and store it+-- in a lazy-valued finite map/dictionary:+--+-- @+-- insert "hello" (arr `index` 12) m+-- @+--+-- This can actually lead to a space leak. The value is not actually extracted+-- from the array until that value (now buried in a map) is forced. That means+-- the entire array may be kept live by just that value!  Often, the solution+-- is to use a strict map, or to force the value before storing it, but for+-- some purposes that's undesirable.+--+-- One common solution is to include an indexing function that can produce its+-- result in an arbitrary @Applicative@ context:+--+-- @+-- indexA :: Applicative f => Array a -> Int -> f a+-- @+--+-- When using @indexA@ in a /pure/ context, @Solo@ serves as a handy+-- @Applicative@ functor to hold the result. You could write a non-leaky+-- version of the above example thus:+--+-- @+-- case arr `indexA` 12 of+--   Solo a -> insert "hello" a m+-- @+--+-- While such simple extraction functions are the most common uses for+-- unary tuples, they can also be useful for fine-grained control of+-- strict-spined data structure traversals, and for unifying the+-- implementations of lazy and strict mapping functions. data Solo a = Solo a +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+ data (a,b) = (a,b) data (a,b,c) = (a,b,c) data (a,b,c,d) = (a,b,c,d)@@ -166,82 +222,11 @@       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)--{- Manuel says: Including one more declaration gives a segmentation fault.-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___  u___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___-data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___  u___ v___- = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ v___--}+data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,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,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,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)

@@ -30,14 +30,17 @@         Ordering(..), IO(..),         isTrue#,         SPEC(..),-        Nat, Symbol,+        Symbol,         Any,         type (~~), Coercible,-        TYPE, RuntimeRep(..), Type, Constraint,+        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(..),@@ -84,9 +87,19 @@ -- | 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+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@@ -97,13 +110,10 @@  {- ********************************************************************* *                                                                      *-                  Nat and Symbol+                  Symbol *                                                                      * ********************************************************************* -} --- | (Kind) This is the kind of type-level natural numbers.-data Nat- -- | (Kind) This is the kind of type-level symbols. -- Declared here because class IP needs it data Symbol@@ -412,6 +422,8 @@ *                                                                      * ********************************************************************* -} +-- | 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@@ -427,8 +439,7 @@ 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-                | LiftedRep       -- ^ lifted; represented by a pointer-                | UnliftedRep     -- ^ unlifted; represented by a pointer+                | BoxedRep Levity -- ^ boxed; represented by a pointer                 | IntRep          -- ^ signed, word-sized value                 | Int8Rep         -- ^ signed,  8-bit value                 | Int16Rep        -- ^ signed, 16-bit value@@ -446,6 +457,7 @@ -- 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@@ -469,6 +481,9 @@              | DoubleElemRep -- Enum, Bounded instances in GHC.Enum +{-# DEPRECATED Void# "Void# is now an alias for the unboxed tuple (# #)." #-}+type Void# = (# #)+ {- ********************************************************************* *                                                                      *              Runtime representation of TyCon@@ -525,6 +540,7 @@  data TypeLitSort = TypeLitSymbol                  | TypeLitNat+                 | TypeLitChar  -- Show instance for TyCon found in GHC.Show data TyCon = TyCon WORD64_TY  -- ^ Fingerprint (high)

@@ -32,31 +32,32 @@  /* Relational operators */ +HsInt hs_eq64 (HsWord64 a, HsWord64 b) {return a == b;}+HsInt hs_ne64 (HsWord64 a, HsWord64 b) {return a != b;}+ HsInt hs_gtWord64 (HsWord64 a, HsWord64 b) {return a >  b;} HsInt hs_geWord64 (HsWord64 a, HsWord64 b) {return a >= b;}-HsInt hs_eqWord64 (HsWord64 a, HsWord64 b) {return a == b;}-HsInt hs_neWord64 (HsWord64 a, HsWord64 b) {return a != b;} HsInt hs_ltWord64 (HsWord64 a, HsWord64 b) {return a <  b;} HsInt hs_leWord64 (HsWord64 a, HsWord64 b) {return a <= b;}  HsInt hs_gtInt64 (HsInt64 a, HsInt64 b) {return a >  b;} HsInt hs_geInt64 (HsInt64 a, HsInt64 b) {return a >= b;}-HsInt hs_eqInt64 (HsInt64 a, HsInt64 b) {return a == b;}-HsInt hs_neInt64 (HsInt64 a, HsInt64 b) {return a != b;} HsInt hs_ltInt64 (HsInt64 a, HsInt64 b) {return a <  b;} HsInt hs_leInt64 (HsInt64 a, HsInt64 b) {return a <= b;}  /* Arithmetic operators */ +HsInt64 hs_neg64       (HsInt64 a)              {return - a;}++HsWord64 hs_add64      (HsWord64 a, HsWord64 b) {return a + b;}+HsWord64 hs_sub64      (HsWord64 a, HsWord64 b) {return a - b;}+HsWord64 hs_mul64      (HsWord64 a, HsWord64 b) {return a * b;}+ HsWord64 hs_remWord64  (HsWord64 a, HsWord64 b) {return a % b;} HsWord64 hs_quotWord64 (HsWord64 a, HsWord64 b) {return a / b;}  HsInt64 hs_remInt64    (HsInt64 a, HsInt64 b)   {return a % b;} HsInt64 hs_quotInt64   (HsInt64 a, HsInt64 b)   {return a / b;}-HsInt64 hs_negateInt64 (HsInt64 a)              {return -a;}-HsInt64 hs_plusInt64   (HsInt64 a, HsInt64 b)   {return a + b;}-HsInt64 hs_minusInt64  (HsInt64 a, HsInt64 b)   {return a - b;}-HsInt64 hs_timesInt64  (HsInt64 a, HsInt64 b)   {return a * b;}  /* Logical operators: */ @@ -71,10 +72,7 @@    the behaviour you'll get from using these primops depends    on the whatever your C compiler is doing. ToDo: fix. -- sof 8/98 */-HsInt64  hs_uncheckedIShiftL64  (HsInt64 a,  HsInt b)    {return a << b;} HsInt64  hs_uncheckedIShiftRA64 (HsInt64 a,  HsInt b)    {return a >> b;}-HsInt64  hs_uncheckedIShiftRL64 (HsInt64 a,  HsInt b)-                                    {return (HsInt64) ((HsWord64) a >> b);}  /* Casting between longs and longer longs. */

@@ -1,5 +1,25 @@-## 0.7.0 (*Jan 2021*)+## 0.8.0 +- Shipped with GHC 9.2.1++- Change array access primops to use type with size maxing the element size:++   - `index{Int,Word}<N>Array# :: ByteArray# -> Int# -> {Int,Word}<N>#`+   - `indexWord8ArrayAs{Int,Word}<N># :: ByteArray# -> Int# -> {Int,Word}<N>#`+   - `read{Int,Word}<N>Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}<N># #)`+   - `write{Int,Word}<N>Array# :: MutableByteArray# s -> Int# -> {Int,Word}<N># -> State# s -> State# s`+   - `readWord8ArrayAs{Int,Word}<N># :: MutableByteArray# s -> Int# -> State# s -> (# State# s, {Int,Word}<N># #)`+   - `writeWord8ArrayAs{Int,Word}<N># :: MutableByteArray# s -> Int# -> {Int,Word}<N># -> State# s -> State# s`++  This was already the for the 64-bit access primops, but not the smaller ones.++- Rename some numeric prim type conversion primops:++   - `extend{Int,Word}<N>#` -> `extend<N>To{Int,Word}#`+   - `narrow{Int,Word}<N>#` -> `intTo{Int,Word}<N>#`++## 0.7.0+ - Shipped with GHC 9.0.1  - Add known-key `cstringLength#` to `GHC.CString`. This is just the@@ -12,7 +32,7 @@         unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char]         unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a -- `unpackFoldrCString*` variants can now inline in phase `[0]`.+- unpackFoldrCString* variants can now inline in phase [0].    If the folding function is known this allows for unboxing of the   Char argument resulting in much faster code.@@ -24,7 +44,7 @@         atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s, Addr# #)         atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) -- Add primops for atomic compare and swap at a given `Addr#`:+- Add primops for atomic compare and swap at a given Addr#:          atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s, Addr# #)         atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s, Word# #)@@ -37,7 +57,7 @@   the soundness issues of the latter (see   [#17760](https://gitlab.haskell.org/ghc/ghc/-/issues/17760)). -## 0.6.1 (*March 2020*)+## 0.6.1 (edit as necessary)  - Shipped with GHC 8.10.1 

@@ -1,6 +1,6 @@ cabal-version:  2.2 name:           ghc-prim-version:        0.7.0+version:        0.8.0 -- NOTE: Don't forget to update ./changelog.md license:        BSD-3-Clause license-file:   LICENSE@@ -43,7 +43,6 @@         GHC.CString         GHC.Classes         GHC.Debug-        GHC.IntWord64         GHC.Magic         GHC.Prim.Ext         GHC.Prim.Panic