diff --git a/GHC/Classes.hs b/GHC/Classes.hs
--- a/GHC/Classes.hs
+++ b/GHC/Classes.hs
@@ -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)
diff --git a/GHC/IntWord64.hs b/GHC/IntWord64.hs
deleted file mode 100644
--- a/GHC/IntWord64.hs
+++ /dev/null
@@ -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
-
diff --git a/GHC/Magic.hs b/GHC/Magic.hs
--- a/GHC/Magic.hs
+++ b/GHC/Magic.hs
@@ -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
diff --git a/GHC/Prim/Exception.hs b/GHC/Prim/Exception.hs
--- a/GHC/Prim/Exception.hs
+++ b/GHC/Prim/Exception.hs
@@ -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
diff --git a/GHC/Prim/Ext.hs b/GHC/Prim/Ext.hs
--- a/GHC/Prim/Ext.hs
+++ b/GHC/Prim/Ext.hs
@@ -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.
 
diff --git a/GHC/Prim/Panic.hs b/GHC/Prim/Panic.hs
--- a/GHC/Prim/Panic.hs
+++ b/GHC/Prim/Panic.hs
@@ -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)
diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs
--- a/GHC/PrimopWrappers.hs
+++ b/GHC/PrimopWrappers.hs
@@ -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
diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs
--- a/GHC/Tuple.hs
+++ b/GHC/Tuple.hs
@@ -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)
diff --git a/GHC/Types.hs b/GHC/Types.hs
--- a/GHC/Types.hs
+++ b/GHC/Types.hs
@@ -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)
diff --git a/cbits/longlong.c b/cbits/longlong.c
--- a/cbits/longlong.c
+++ b/cbits/longlong.c
@@ -32,31 +32,32 @@
 
 /* Relational operators */
 
+HsInt hs_eq64 (HsWord64 a, HsWord64 b) {return a == b;}
+HsInt hs_ne64 (HsWord64 a, HsWord64 b) {return a != b;}
+
 HsInt hs_gtWord64 (HsWord64 a, HsWord64 b) {return a >  b;}
 HsInt hs_geWord64 (HsWord64 a, HsWord64 b) {return a >= b;}
-HsInt hs_eqWord64 (HsWord64 a, HsWord64 b) {return a == b;}
-HsInt hs_neWord64 (HsWord64 a, HsWord64 b) {return a != b;}
 HsInt hs_ltWord64 (HsWord64 a, HsWord64 b) {return a <  b;}
 HsInt hs_leWord64 (HsWord64 a, HsWord64 b) {return a <= b;}
 
 HsInt hs_gtInt64 (HsInt64 a, HsInt64 b) {return a >  b;}
 HsInt hs_geInt64 (HsInt64 a, HsInt64 b) {return a >= b;}
-HsInt hs_eqInt64 (HsInt64 a, HsInt64 b) {return a == b;}
-HsInt hs_neInt64 (HsInt64 a, HsInt64 b) {return a != b;}
 HsInt hs_ltInt64 (HsInt64 a, HsInt64 b) {return a <  b;}
 HsInt hs_leInt64 (HsInt64 a, HsInt64 b) {return a <= b;}
 
 /* Arithmetic operators */
 
+HsInt64 hs_neg64       (HsInt64 a)              {return - a;}
+
+HsWord64 hs_add64      (HsWord64 a, HsWord64 b) {return a + b;}
+HsWord64 hs_sub64      (HsWord64 a, HsWord64 b) {return a - b;}
+HsWord64 hs_mul64      (HsWord64 a, HsWord64 b) {return a * b;}
+
 HsWord64 hs_remWord64  (HsWord64 a, HsWord64 b) {return a % b;}
 HsWord64 hs_quotWord64 (HsWord64 a, HsWord64 b) {return a / b;}
 
 HsInt64 hs_remInt64    (HsInt64 a, HsInt64 b)   {return a % b;}
 HsInt64 hs_quotInt64   (HsInt64 a, HsInt64 b)   {return a / b;}
-HsInt64 hs_negateInt64 (HsInt64 a)              {return -a;}
-HsInt64 hs_plusInt64   (HsInt64 a, HsInt64 b)   {return a + b;}
-HsInt64 hs_minusInt64  (HsInt64 a, HsInt64 b)   {return a - b;}
-HsInt64 hs_timesInt64  (HsInt64 a, HsInt64 b)   {return a * b;}
 
 /* Logical operators: */
 
@@ -71,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.
 */
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -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
 
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.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