-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Experimental features of GHC's standard library and unstable GHC internals.
--   
--   This package is where experimental GHC standard library interfaces
--   start life and mature. Eventually, stabilized interfaces will be
--   migrated into the <tt>base</tt> library.
--   
--   This library also exposes some interfaces that are considered too
--   unstable for the <tt>base</tt> library like primitives built into GHC.
@package ghc-experimental
@version 9.1401.0

module Data.Sum.Experimental
data (# | #) (a :: TYPE k0) (b :: TYPE k1) :: TYPE 'SumRep '[k0, k1]
data (# | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) :: TYPE 'SumRep '[k0, k1, k2]
data (# | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) :: TYPE 'SumRep '[k0, k1, k2, k3]
data (# | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) :: TYPE 'SumRep '[k0, k1, k2, k3, k4]
data (# | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5]
data (# | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6]
data (# | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7]
data (# | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8]
data (# | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9]
data (# | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10]
data (# | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11]
data (# | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12]
data (# | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13]
data (# | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14]
data (# | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15]
data (# | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16]
data (# | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17]
data (# | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18]
data (# | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19]
data (# | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20]
data (# | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21]
data (# | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22]
data (# | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23]
data (# | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) (t61 :: TYPE k61) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61]
data (# | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) (t61 :: TYPE k61) (t62 :: TYPE k62) :: TYPE 'SumRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61, k62]

module Data.Tuple.Experimental

-- | Extract the value from a <a>Solo</a>. Very often, values should be
--   extracted directly using pattern matching, to control just what gets
--   evaluated when. <tt>getSolo</tt> is for convenience in situations
--   where that is not the case:
--   
--   When the result is passed to a <i>strict</i> function, it makes no
--   difference whether the pattern matching is done on the "outside" or on
--   the "inside":
--   
--   <pre>
--   Data.Set.insert (getSolo sol) set === case sol of Solo v -&gt; Data.Set.insert v set
--   </pre>
--   
--   A traversal may be performed in <a>Solo</a> in order to control
--   evaluation internally, while using <tt>getSolo</tt> to extract the
--   final result. A strict mapping function, for example, could be defined
--   
--   <pre>
--   map' :: Traversable t =&gt; (a -&gt; b) -&gt; t a -&gt; t b
--   map' f = getSolo . traverse ((Solo $!) . f)
--   </pre>
getSolo :: Solo a -> a

-- | A tuple of zero elements, a synonym for <a>()</a>.
type Tuple0 = ()

-- | A tuple of one element, a synonym for <a>Solo</a>.
type Tuple1 = Solo

-- | <tt>Solo</tt> is the canonical lifted 1-tuple, just like <a>(,)</a> is
--   the canonical lifted 2-tuple (pair) and <a>(,,)</a> is the canonical
--   lifted 3-tuple (triple).
--   
--   The most important feature of <tt>Solo</tt> 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:
--   
--   <pre>
--   index :: Array a -&gt; Int -&gt; a
--   </pre>
--   
--   Now imagine that someone wants to extract a value from an array and
--   store it in a lazy-valued finite map/dictionary:
--   
--   <pre>
--   insert "hello" (arr <tt>index</tt> 12) m
--   </pre>
--   
--   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 <tt>Applicative</tt> context:
--   
--   <pre>
--   indexA :: Applicative f =&gt; Array a -&gt; Int -&gt; f a
--   </pre>
--   
--   When using <tt>indexA</tt> in a <i>pure</i> context, <tt>Solo</tt>
--   serves as a handy <tt>Applicative</tt> functor to hold the result. You
--   could write a non-leaky version of the above example thus:
--   
--   <pre>
--   case arr <tt>indexA</tt> 12 of
--     Solo a -&gt; insert "hello" a m
--   </pre>
--   
--   While such simple extraction functions are the most common uses for
--   unary tuples, they can also be useful for fine-grained control of
--   strict-spined data structure traversals, and for unifying the
--   implementations of lazy and strict mapping functions.
data Solo a
MkSolo :: a -> Solo a

-- | <i>Deprecated: The Solo constructor has been renamed to MkSolo to
--   avoid punning.</i>
pattern Solo :: a -> Solo a

-- | A tuple of ten elements.
data (,,,,,,,,,) a b c d e f g h i j

-- | A tuple of eleven elements.
data (,,,,,,,,,,) a b c d e f g h i j k

-- | A tuple of twelve elements.
data (,,,,,,,,,,,) a b c d e f g h i j k l

-- | A tuple of 13 elements.
data (,,,,,,,,,,,,) a b c d e f g h i j k l m

-- | A tuple of 14 elements.
data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n

-- | A tuple of 15 elements.
data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o

-- | A tuple of 16 elements.
data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p

-- | A tuple of 17 elements.
data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q

-- | A tuple of 18 elements.
data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r

-- | A tuple of 19 elements.
data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s

-- | A tuple of two elements.
data (,) a b

-- | A tuple of 20 elements.
data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t

-- | A tuple of 21 elements.
data (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u

-- | A tuple of 22 elements.
data (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v

-- | A tuple of 23 elements.
data (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w

-- | A tuple of 24 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x

-- | A tuple of 25 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y

-- | A tuple of 26 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z

-- | A tuple of 27 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26

-- | A tuple of 28 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27

-- | A tuple of 29 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28

-- | A tuple of three elements.
data (,,) a b c

-- | A tuple of 30 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29

-- | A tuple of 31 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30

-- | A tuple of 32 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31

-- | A tuple of 33 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32

-- | A tuple of 34 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33

-- | A tuple of 35 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34

-- | A tuple of 36 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35

-- | A tuple of 37 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36

-- | A tuple of 38 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37

-- | A tuple of 39 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38

-- | A tuple of four elements.
data (,,,) a b c d

-- | A tuple of 40 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39

-- | A tuple of 41 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40

-- | A tuple of 42 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41

-- | A tuple of 43 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42

-- | A tuple of 44 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43

-- | A tuple of 45 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44

-- | A tuple of 46 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45

-- | A tuple of 47 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46

-- | A tuple of 48 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47

-- | A tuple of 49 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48

-- | A tuple of five elements.
data (,,,,) a b c d e

-- | A tuple of 50 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49

-- | A tuple of 51 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50

-- | A tuple of 52 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51

-- | A tuple of 53 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52

-- | A tuple of 54 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53

-- | A tuple of 55 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54

-- | A tuple of 56 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55

-- | A tuple of 57 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56

-- | A tuple of 58 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57

-- | A tuple of 59 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58

-- | A tuple of six elements.
data (,,,,,) a b c d e f

-- | A tuple of 60 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59

-- | A tuple of 61 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60

-- | A tuple of 62 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61

-- | A tuple of 63 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61 t62

-- | A tuple of 64 elements.
data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61 t62 t63

-- | A tuple of seven elements.
data (,,,,,,) a b c d e f g

-- | A tuple of eight elements.
data (,,,,,,,) a b c d e f g h

-- | A tuple of nine elements.
data (,,,,,,,,) a b c d e f g h i

-- | The unit datatype <tt>Unit</tt> has one non-undefined member, the
--   nullary constructor <tt>()</tt>.
data ()

-- | <tt>Solo</tt> is the canonical lifted 1-tuple, just like <a>(,)</a> is
--   the canonical lifted 2-tuple (pair) and <a>(,,)</a> is the canonical
--   lifted 3-tuple (triple).
--   
--   The most important feature of <tt>Solo</tt> 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:
--   
--   <pre>
--   index :: Array a -&gt; Int -&gt; a
--   </pre>
--   
--   Now imagine that someone wants to extract a value from an array and
--   store it in a lazy-valued finite map/dictionary:
--   
--   <pre>
--   insert "hello" (arr <tt>index</tt> 12) m
--   </pre>
--   
--   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 <tt>Applicative</tt> context:
--   
--   <pre>
--   indexA :: Applicative f =&gt; Array a -&gt; Int -&gt; f a
--   </pre>
--   
--   When using <tt>indexA</tt> in a <i>pure</i> context, <tt>Solo</tt>
--   serves as a handy <tt>Applicative</tt> functor to hold the result. You
--   could write a non-leaky version of the above example thus:
--   
--   <pre>
--   case arr <tt>indexA</tt> 12 of
--     Solo a -&gt; insert "hello" a m
--   </pre>
--   
--   While such simple extraction functions are the most common uses for
--   unary tuples, they can also be useful for fine-grained control of
--   strict-spined data structure traversals, and for unifying the
--   implementations of lazy and strict mapping functions.
data Solo a
MkSolo :: a -> Solo a

-- | <i>Deprecated: The Solo constructor has been renamed to MkSolo to
--   avoid punning.</i>
pattern Solo :: a -> Solo a
data (##) :: ZeroBitType
data Solo# (a :: TYPE k) :: TYPE 'TupleRep '[k]
MkSolo# :: a -> Solo# (a :: TYPE k)
type Tuple0# = (# #)
type Tuple1# = Solo# :: Type -> TYPE 'TupleRep '[LiftedRep]
data (#,#) (a :: TYPE k0) (b :: TYPE k1) :: TYPE 'TupleRep '[k0, k1]
data (#,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) :: TYPE 'TupleRep '[k0, k1, k2]
data (#,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) :: TYPE 'TupleRep '[k0, k1, k2, k3]
data (#,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4]
data (#,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5]
data (#,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6]
data (#,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7]
data (#,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8]
data (#,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9]
data (#,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10]
data (#,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11]
data (#,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12]
data (#,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13]
data (#,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14]
data (#,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15]
data (#,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16]
data (#,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17]
data (#,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18]
data (#,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19]
data (#,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20]
data (#,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21]
data (#,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22]
data (#,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23]
data (#,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) (t61 :: TYPE k61) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) (t61 :: TYPE k61) (t62 :: TYPE k62) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61, k62]
data (#,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#) (a :: TYPE k0) (b :: TYPE k1) (c :: TYPE k2) (d :: TYPE k3) (e :: TYPE k4) (f :: TYPE k5) (g :: TYPE k6) (h :: TYPE k7) (i :: TYPE k8) (j :: TYPE k9) (k :: TYPE k10) (l :: TYPE k11) (m :: TYPE k12) (n :: TYPE k13) (o :: TYPE k14) (p :: TYPE k15) (q :: TYPE k16) (r :: TYPE k17) (s :: TYPE k18) (t :: TYPE k19) (u :: TYPE k20) (v :: TYPE k21) (w :: TYPE k22) (x :: TYPE k23) (y :: TYPE k24) (z :: TYPE k25) (t26 :: TYPE k26) (t27 :: TYPE k27) (t28 :: TYPE k28) (t29 :: TYPE k29) (t30 :: TYPE k30) (t31 :: TYPE k31) (t32 :: TYPE k32) (t33 :: TYPE k33) (t34 :: TYPE k34) (t35 :: TYPE k35) (t36 :: TYPE k36) (t37 :: TYPE k37) (t38 :: TYPE k38) (t39 :: TYPE k39) (t40 :: TYPE k40) (t41 :: TYPE k41) (t42 :: TYPE k42) (t43 :: TYPE k43) (t44 :: TYPE k44) (t45 :: TYPE k45) (t46 :: TYPE k46) (t47 :: TYPE k47) (t48 :: TYPE k48) (t49 :: TYPE k49) (t50 :: TYPE k50) (t51 :: TYPE k51) (t52 :: TYPE k52) (t53 :: TYPE k53) (t54 :: TYPE k54) (t55 :: TYPE k55) (t56 :: TYPE k56) (t57 :: TYPE k57) (t58 :: TYPE k58) (t59 :: TYPE k59) (t60 :: TYPE k60) (t61 :: TYPE k61) (t62 :: TYPE k62) (t63 :: TYPE k63) :: TYPE 'TupleRep '[k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61, k62, k63]
class ()
class a => CSolo a
type CTuple0 = ()
type CTuple1 = CSolo
class (a, b) => (,) a b
class (a, b, c) => (,,) a b c
class (a, b, c, d) => (,,,) a b c d
class (a, b, c, d, e) => (,,,,) a b c d e
class (a, b, c, d, e, f) => (,,,,,) a b c d e f
class (a, b, c, d, e, f, g) => (,,,,,,) a b c d e f g
class (a, b, c, d, e, f, g, h) => (,,,,,,,) a b c d e f g h
class (a, b, c, d, e, f, g, h, i) => (,,,,,,,,) a b c d e f g h i
class (a, b, c, d, e, f, g, h, i, j) => (,,,,,,,,,) a b c d e f g h i j
class (a, b, c, d, e, f, g, h, i, j, k) => (,,,,,,,,,,) a b c d e f g h i j k
class (a, b, c, d, e, f, g, h, i, j, k, l) => (,,,,,,,,,,,) a b c d e f g h i j k l
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (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
class (a, 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
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) => (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26) => (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60, t61) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60, t61, t62) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61 t62
class (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40, t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60, t61, t62, t63) => (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z t26 t27 t28 t29 t30 t31 t32 t33 t34 t35 t36 t37 t38 t39 t40 t41 t42 t43 t44 t45 t46 t47 t48 t49 t50 t51 t52 t53 t54 t55 t56 t57 t58 t59 t60 t61 t62 t63

module GHC.Exception.Backtrace.Experimental

-- | How to collect a backtrace when an exception is thrown.
data BacktraceMechanism

-- | collect cost-centre stack backtraces (only available when built with
--   profiling)
CostCentreBacktrace :: BacktraceMechanism

-- | collect <a>HasCallStack</a> backtraces
HasCallStackBacktrace :: BacktraceMechanism

-- | collect backtraces via native execution stack unwinding (e.g. using
--   DWARF debug information)
ExecutionBacktrace :: BacktraceMechanism

-- | collect backtraces from Info Table Provenance Entries
IPEBacktrace :: BacktraceMechanism

-- | Will the given <a>BacktraceMechanism</a> be used when collecting
--   backtraces?
getBacktraceMechanismState :: BacktraceMechanism -> IO Bool

-- | Set whether the given <a>BacktraceMechanism</a> will be used when
--   collecting backtraces?
setBacktraceMechanismState :: BacktraceMechanism -> Bool -> IO ()

-- | A collection of backtraces.
data Backtraces
Backtraces :: Maybe (Ptr CostCentreStack) -> Maybe CallStack -> Maybe StackTrace -> Maybe StackSnapshot -> Backtraces
[btrCostCentre] :: Backtraces -> Maybe (Ptr CostCentreStack)
[btrHasCallStack] :: Backtraces -> Maybe CallStack
[btrExecutionStack] :: Backtraces -> Maybe StackTrace
[btrIpe] :: Backtraces -> Maybe StackSnapshot

-- | Render a set of backtraces to a human-readable string.
displayBacktraces :: Backtraces -> String

-- | Collect a set of <a>Backtraces</a>.
collectBacktraces :: (?callStack :: CallStack) => IO Backtraces

-- | How to collect <a>ExceptionAnnotation</a>s on throwing
--   <tt>Exception</tt>s.
data CollectExceptionAnnotationMechanism

-- | Returns the current callback for collecting
--   <a>ExceptionAnnotation</a>s on throwing <tt>Exception</tt>s.
getCollectExceptionAnnotationMechanism :: IO CollectExceptionAnnotationMechanism

-- | Set the callback for collecting an <a>ExceptionAnnotation</a>.
setCollectExceptionAnnotation :: ExceptionAnnotation a => (HasCallStack => IO a) -> IO ()

-- | Collect <a>SomeExceptionAnnotation</a> based on the configuration of
--   the global <a>CollectExceptionAnnotationMechanism</a>.
collectExceptionAnnotation :: HasCallStack => IO SomeExceptionAnnotation


-- | GHC Extensions: This is the Approved Way to get at GHC-specific
--   extensions without relying on the ghc-internal package.
module GHC.PrimOps

-- | Copy a range of the <a>ArrayArray#</a> to the specified region in the
--   <a>MutableArrayArray#</a>. Both arrays must fully contain the
--   specified ranges, but this is not checked. The two arrays must not be
--   the same array in different states, but this is not checked either.
copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s

-- | Copy a range of the first MutableArrayArray# to the specified region
--   in the second MutableArrayArray#. Both arrays must fully contain the
--   specified ranges, but this is not checked. The regions are allowed to
--   overlap, although this is only possible when the same array is
--   provided as both the source and the destination.
copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#

-- | Create a new mutable array of arrays with the specified number of
--   elements, in the specified state thread, with each element recursively
--   referring to the newly created array.
newArrayArray# :: Int# -> State# s -> (# State# s, MutableArrayArray# s #)
readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, ArrayArray# #)
readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, ByteArray# #)
readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)

-- | Compare the underlying pointers of two arrays of arrays.
sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#

-- | Compare the underlying pointers of two mutable arrays of arrays.
sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#

-- | Return the number of elements in the array.
sizeofArrayArray# :: ArrayArray# -> Int#

-- | Return the number of elements in the array.
sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#

-- | Make a mutable array of arrays immutable, without copying.
unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s, ArrayArray# #)
writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s

-- | A list producer that can be fused with <a>foldr</a>. This function is
--   merely
--   
--   <pre>
--   augment g xs = g (:) xs
--   </pre>
--   
--   but GHC's simplifier will transform an expression of the form
--   <tt><a>foldr</a> k z (<a>augment</a> g xs)</tt>, which may arise after
--   inlining, to <tt>g k (<a>foldr</a> k z xs)</tt>, which avoids
--   producing an intermediate list.
augment :: (forall b. () => (a -> b -> b) -> b -> b) -> [a] -> [a]
breakpoint :: a -> a
breakpointCond :: Bool -> a -> a

-- | A list producer that can be fused with <a>foldr</a>. This function is
--   merely
--   
--   <pre>
--   build g = g (:) []
--   </pre>
--   
--   but GHC's simplifier will transform an expression of the form
--   <tt><a>foldr</a> k z (<a>build</a> g)</tt>, which may arise after
--   inlining, to <tt>g k z</tt>, which avoids producing an intermediate
--   list.
build :: (forall b. () => (a -> b -> b) -> b -> b) -> [a]

-- | Shift the argument left by the specified number of bits (which must be
--   non-negative).
iShiftL# :: Int# -> Int# -> Int#

-- | Shift the argument right (signed) by the specified number of bits
--   (which must be non-negative). The <a>RA</a> means "right, arithmetic"
--   (as opposed to RL for logical)
iShiftRA# :: Int# -> Int# -> Int#

-- | Shift the argument right (unsigned) by the specified number of bits
--   (which must be non-negative). The <a>RL</a> means "right, logical" (as
--   opposed to RA for arithmetic)
iShiftRL# :: Int# -> Int# -> Int#

-- | Shift the argument left by the specified number of bits (which must be
--   non-negative).
shiftL# :: Word# -> Int# -> Word#

-- | Shift the argument right by the specified number of bits (which must
--   be non-negative). The <a>RL</a> means "right, logical" (as opposed to
--   RA for arithmetic) (although an arithmetic right shift wouldn't make
--   sense for Word#)
shiftRL# :: Word# -> Int# -> Word#

-- | Compute the length of a NUL-terminated string. This address must refer
--   to immutable memory. GHC includes a built-in rule for constant folding
--   when the argument is a statically-known literal. That is, a
--   core-to-core pass reduces the expression <tt>cstringLength#
--   "hello"#</tt> to the constant <tt>5#</tt>.
cstringLength# :: Addr# -> Int#
unpackAppendCString# :: Addr# -> [Char] -> [Char]
unpackCString# :: Addr# -> [Char]
unpackCStringUtf8# :: Addr# -> [Char]
unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
unpackNBytes# :: Addr# -> Int# -> [Char]

-- | An implementation of the old <tt>atomicModifyMutVar#</tt> primop in
--   terms of the new <a>atomicModifyMutVar2#</a> primop, for backwards
--   compatibility. The type of this function is a bit bogus. It's best to
--   think of it as having type
--   
--   <pre>
--   atomicModifyMutVar#
--     :: MutVar# s a
--     -&gt; (a -&gt; (a, b))
--     -&gt; State# s
--     -&gt; (# State# s, b #)
--   </pre>
--   
--   but there may be code that uses this with other two-field record
--   types.
atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)

-- | Semantically, <tt>considerAccessible = True</tt>. But it has special
--   meaning to the pattern-match checker, which will never flag the clause
--   in which <a>considerAccessible</a> occurs as a guard as redundant or
--   inaccessible. Example:
--   
--   <pre>
--   case (x, x) of
--     (True,  True)  -&gt; 1
--     (False, False) -&gt; 2
--     (True,  False) -&gt; 3 -- Warning: redundant
--   </pre>
--   
--   The pattern-match checker will warn here that the third clause is
--   redundant. It will stop doing so if the clause is adorned with
--   <a>considerAccessible</a>:
--   
--   <pre>
--   case (x, x) of
--     (True,  True)  -&gt; 1
--     (False, False) -&gt; 2
--     (True,  False) | considerAccessible -&gt; 3 -- No warning
--   </pre>
--   
--   Put <a>considerAccessible</a> as the last statement of the guard to
--   avoid get confusing results from the pattern-match checker, which
--   takes "consider accessible" by word.
considerAccessible :: Bool

-- | The <a>groupWith</a> function uses the user supplied function which
--   projects an element out of every list element in order to first sort
--   the input list and then to form groups by equality on these projected
--   elements
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
maxTupleSize :: Int

-- | Resize a mutable array to new specified size. The returned
--   <a>SmallMutableArray#</a> is either the original
--   <a>SmallMutableArray#</a> resized in-place or, if not possible, a
--   newly allocated <a>SmallMutableArray#</a> with the original content
--   copied over.
--   
--   To avoid undefined behaviour, the original <a>SmallMutableArray#</a>
--   shall not be accessed anymore after a <a>resizeSmallMutableArray#</a>
--   has been performed. Moreover, no reference to the old one should be
--   kept in order to allow garbage collection of the original
--   <a>SmallMutableArray#</a> in case a new <a>SmallMutableArray#</a> had
--   to be allocated.
resizeSmallMutableArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)

-- | The <a>sortWith</a> function sorts a list of elements using the user
--   supplied function to project something out of each element
--   
--   In general if the user supplied function is expensive to compute then
--   you should probably be using <a>sortOn</a>, as it only needs to
--   compute it once for each element. <a>sortWith</a>, on the other hand
--   must compute the mapping function for every comparison that it
--   performs.
sortWith :: Ord b => (a -> b) -> [a] -> [a]

-- | <a>the</a> ensures that all the elements of the list are identical and
--   then returns that unique element
the :: Eq a => [a] -> a

-- | <i>Deprecated: Use <a>traceEvent</a> or <a>traceEventIO</a></i>
traceEvent :: String -> IO ()

-- | The primitive used to implement <a>evaluate</a>. Prefer to use
--   <a>evaluate</a> whenever possible!
seq# :: a -> State# s -> (# State# s, a #)

-- | The call <tt>inline f</tt> arranges that <tt>f</tt> is inlined,
--   regardless of its size. More precisely, the call <tt>inline f</tt>
--   rewrites to the right-hand side of <tt>f</tt>'s definition. This
--   allows the programmer to control inlining from a particular call site
--   rather than the definition site of the function (c.f. <tt>INLINE</tt>
--   pragmas).
--   
--   This inlining occurs regardless of the argument to the call or the
--   size of <tt>f</tt>'s definition; it is unconditional. The main caveat
--   is that <tt>f</tt>'s definition must be visible to the compiler; it is
--   therefore recommended to mark the function with an <tt>INLINABLE</tt>
--   pragma at its definition so that GHC guarantees to record its
--   unfolding regardless of size.
--   
--   If no inlining takes place, the <a>inline</a> function expands to the
--   identity function in Phase zero, so its use imposes no overhead.
inline :: a -> a

-- | Apply a function to a <tt><a>State#</a> <a>RealWorld</a></tt> token.
--   When manually applying a function to <a>realWorld#</a>, it is
--   necessary to use <tt>NOINLINE</tt> to prevent semantically undesirable
--   floating. <a>runRW#</a> is inlined, but only very late in compilation
--   after all floating is complete.
runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o

-- | Retrieves the allocation counter for the current thread.
getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, Int64# #)

-- | Compare two stable names for equality.
eqStableName# :: forall {k :: Levity} {l :: Levity} (a :: TYPE ('BoxedRep k)) (b :: TYPE ('BoxedRep l)). StableName# a -> StableName# b -> Int#

-- | Compare the underlying pointers of two values for equality.
--   
--   Returns <tt>1</tt> if the pointers are equal and <tt>0</tt> otherwise.
--   
--   The two values must be of the same type, of kind <tt>Type</tt>. See
--   also <a>reallyUnsafePtrEquality#</a>, which doesn't have such
--   restrictions.
reallyUnsafePtrEquality :: a -> a -> Int#

-- | Compare the underlying pointers of two arrays.
sameArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Array# a -> Int#

-- | Compare the pointers of two byte arrays.
sameByteArray# :: ByteArray# -> ByteArray# -> Int#

-- | Compare the underlying pointers of two <a>MVar#</a>s.
sameMVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MVar# s a -> MVar# s a -> Int#

-- | Compare the underlying pointers of two <a>MutVar#</a>s.
sameMutVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#

-- | Compare the underlying pointers of two mutable arrays.
sameMutableArray# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#

-- | Compare the underlying pointers of two mutable byte arrays.
sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#

-- | Compare the underlying pointers of two <a>PromptTag#</a>s.
samePromptTag# :: PromptTag# a -> PromptTag# a -> Int#

-- | Compare the underlying pointers of two small arrays.
sameSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#

-- | Compare the underlying pointers of two small mutable arrays.
sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#

-- | Compare the underlying pointers of two <a>TVar#</a>s.
sameTVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). TVar# s a -> TVar# s a -> Int#

-- | Compare the underlying pointers of two unlifted values for equality.
--   
--   This is less dangerous than <a>reallyUnsafePtrEquality</a>, since the
--   arguments are guaranteed to be evaluated. This means there is no risk
--   of accidentally comparing a thunk. It's however still more dangerous
--   than e.g. <a>sameArray#</a>.
unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#

-- | Returns a <tt>[String]</tt> representing the current call stack. This
--   can be useful for debugging.
--   
--   The implementation uses the call-stack simulation maintained by the
--   profiler, so it only works if the program was compiled with
--   <tt>-prof</tt> and contains suitable SCC annotations (e.g. by using
--   <tt>-fprof-auto</tt>). Otherwise, the list returned is likely to be
--   empty or uninformative.
currentCallStack :: IO [String]

-- | Alias for <a>tagToEnum#</a>. Returns True if its parameter is 1# and
--   False if it is 0#.
isTrue# :: Int# -> Bool

-- | Highly, terribly dangerous coercion from one representation type to
--   another. Misuse of this function can invite the garbage collector to
--   trounce upon your data and then laugh in your face. You don't want
--   this function. Really.
--   
--   This becomes more obvious when looking at its actual type: <tt>forall
--   (r1 :: RuntimeRep) (r2 :: RuntimeRep) (a :: TYPE r1) (b :: TYPE r2). a
--   -&gt; b</tt> Which often get's rendered as <tt>a -&gt; b</tt> in
--   haddock for technical reasons.
unsafeCoerce# :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b

-- | The <a>lazy</a> function restrains strictness analysis a little. The
--   call <tt>lazy e</tt> means the same as <tt>e</tt>, but <a>lazy</a> has
--   a magical property so far as strictness analysis is concerned: it is
--   lazy in its first argument, even though its semantics is strict. After
--   strictness analysis has run, calls to <a>lazy</a> are inlined to be
--   the identity function.
--   
--   This behaviour is occasionally useful when controlling evaluation
--   order. Notably, <a>lazy</a> is used in the library definition of
--   <a>par</a>:
--   
--   <pre>
--   par :: a -&gt; b -&gt; b
--   par x y = case (par# x) of _ -&gt; lazy y
--   </pre>
--   
--   If <a>lazy</a> were not lazy, <a>par</a> would look strict in
--   <tt>y</tt> which would defeat the whole purpose of <a>par</a>.
lazy :: a -> a

-- | The call <tt>noinline f</tt> arranges that <tt>f</tt> will not be
--   inlined. It is removed during CorePrep so that its use imposes no
--   overhead (besides the fact that it blocks inlining.)
noinline :: a -> a

-- | The <a>oneShot</a> function can be used to give a hint to the compiler
--   that its argument will be called at most once, which may (or may not)
--   enable certain optimizations. It can be useful to improve the
--   performance of code in continuation passing style.
--   
--   If <a>oneShot</a> is used wrongly, then it may be that computations
--   whose result that would otherwise be shared are re-evaluated every
--   time they are used. Otherwise, the use of <a>oneShot</a> is safe.
--   
--   <a>oneShot</a> is representation-polymorphic: the type variables may
--   refer to lifted or unlifted types.
oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b

-- | Low word of signed integer multiply.
(*#) :: Int# -> Int# -> Int#
infixl 7 *#
(*##) :: Double# -> Double# -> Double#
infixl 7 *##

-- | Exponentiation.
(**##) :: Double# -> Double# -> Double#
(+#) :: Int# -> Int# -> Int#
infixl 6 +#
(+##) :: Double# -> Double# -> Double#
infixl 6 +##
(-#) :: Int# -> Int# -> Int#
infixl 6 -#
(-##) :: Double# -> Double# -> Double#
infixl 6 -##
(/##) :: Double# -> Double# -> Double#
infixl 7 /##
(/=#) :: Int# -> Int# -> Int#
infix 4 /=#
(/=##) :: Double# -> Double# -> Int#
infix 4 /=##
(<#) :: Int# -> Int# -> Int#
infix 4 <#
(<##) :: Double# -> Double# -> Int#
infix 4 <##
(<=#) :: Int# -> Int# -> Int#
infix 4 <=#
(<=##) :: Double# -> Double# -> Int#
infix 4 <=##
(==#) :: Int# -> Int# -> Int#
infix 4 ==#
(==##) :: Double# -> Double# -> Int#
infix 4 ==##
(>#) :: Int# -> Int# -> Int#
infix 4 >#
(>##) :: Double# -> Double# -> Int#
infix 4 >##
(>=#) :: Int# -> Int# -> Int#
infix 4 >=#
(>=##) :: Double# -> Double# -> Int#
infix 4 >=##
acosDouble# :: Double# -> Double#
acosFloat# :: Float# -> Float#
acoshDouble# :: Double# -> Double#
acoshFloat# :: Float# -> Float#

-- | <tt>'addCFinalizerToWeak#' fptr ptr flag eptr w</tt> attaches a C
--   function pointer <tt>fptr</tt> to a weak pointer <tt>w</tt> as a
--   finalizer. If <tt>flag</tt> is zero, <tt>fptr</tt> will be called with
--   one argument, <tt>ptr</tt>. Otherwise, it will be called with two
--   arguments, <tt>eptr</tt> and <tt>ptr</tt>. 'addCFinalizerToWeak#'
--   returns 1 on success, or 0 if <tt>w</tt> is already dead.
addCFinalizerToWeak# :: forall {k :: Levity} (b :: TYPE ('BoxedRep k)). Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)

-- | Add signed integers reporting overflow. First member of result is the
--   sum truncated to an 'Int#'; second member is zero if the true sum fits
--   in an 'Int#', nonzero if overflow occurred (the sum is either too
--   large or too small to fit in an 'Int#').
addIntC# :: Int# -> Int# -> (# Int#, Int# #)

-- | Add unsigned integers reporting overflow. The first element of the
--   pair is the result. The second element is the carry flag, which is
--   nonzero on overflow. See also 'plusWord2#'.
addWordC# :: Word# -> Word# -> (# Word#, Int# #)

-- | Coerce directly from address to int. Users are discouraged from using
--   this operation as it makes little sense on platforms with tagged
--   pointers.
addr2Int# :: Addr# -> Int#

-- | Convert an 'Addr#' to a followable Any type.
addrToAny# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Addr# -> (# a #)
and# :: Word# -> Word# -> Word#
and64# :: Word64# -> Word64# -> Word64#

-- | Bitwise "and".
andI# :: Int# -> Int# -> Int#
andWord16# :: Word16# -> Word16# -> Word16#
andWord32# :: Word32# -> Word32# -> Word32#
andWord8# :: Word8# -> Word8# -> Word8#

-- | Pushes an annotation frame to the stack which can be reported by
--   backtraces.
annotateStack# :: forall {q :: RuntimeRep} b d (a :: TYPE q). b -> (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)

-- | Retrieve the address of any Haskell value. This is essentially an
--   'unsafeCoerce#', but if implemented as such the core lint pass
--   complains and fails to compile. As a primop, it is opaque to core/stg,
--   and only appears in cmm (where the copy propagation pass will get rid
--   of it). Note that "a" must be a value, not a thunk! It's too late for
--   strictness analysis to enforce this, so you're on your own to
--   guarantee this. Also note that 'Addr#' is not a GC pointer - up to you
--   to guarantee that it does not become a dangling pointer immediately
--   after you get it.
anyToAddr# :: a -> State# RealWorld -> (# State# RealWorld, Addr# #)
asinDouble# :: Double# -> Double#
asinFloat# :: Float# -> Float#
asinhDouble# :: Double# -> Double#
asinhFloat# :: Float# -> Float#
atanDouble# :: Double# -> Double#
atanFloat# :: Float# -> Float#
atanhDouble# :: Double# -> Double#
atanhFloat# :: Float# -> Float#

-- | Compare and swap on a word-sized memory location.
--   
--   Use as: s -&gt; atomicCasAddrAddr# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# d -> (# State# d, Addr# #)

-- | Compare and swap on a 16 bit-sized and aligned memory location.
--   
--   Use as: s -&gt; atomicCasWordAddr16# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# d -> (# State# d, Word16# #)

-- | Compare and swap on a 32 bit-sized and aligned memory location.
--   
--   Use as: s -&gt; atomicCasWordAddr32# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# d -> (# State# d, Word32# #)

-- | Compare and swap on a 64 bit-sized and aligned memory location.
--   
--   Use as: s -&gt; atomicCasWordAddr64# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# d -> (# State# d, Word64# #)

-- | Compare and swap on a 8 bit-sized and aligned memory location.
--   
--   Use as: s -&gt; atomicCasWordAddr8# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# d -> (# State# d, Word8# #)

-- | Compare and swap on a word-sized and aligned memory location.
--   
--   Use as: s -&gt; atomicCasWordAddr# location expected desired s
--   
--   This version always returns the old value read. This follows the
--   normal protocol for CAS operations (and matches the underlying
--   instruction on most architectures).
--   
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# d -> (# State# d, Word# #)

-- | The atomic exchange operation. Atomically exchanges the value at the
--   first address with the Addr# given as second argument. Implies a read
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# d -> (# State# d, Addr# #)

-- | The atomic exchange operation. Atomically exchanges the value at the
--   address with the given value. Returns the old value. Implies a read
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicExchangeWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Modify the contents of a 'MutVar#', returning the previous contents
--   <tt>x :: a</tt> and the result of applying the given function to the
--   previous contents <tt>f x :: c</tt>.
--   
--   The <tt>data</tt> type <tt>c</tt> (not a <tt>newtype</tt>!) must be a
--   record whose first field is of lifted type <tt>a :: Type</tt> and is
--   not unpacked. For example, product types <tt>c ~ Solo a</tt> or <tt>c
--   ~ (a, b)</tt> work well. If the record type is both monomorphic and
--   strict in its first field, it's recommended to mark the latter <tt>{-#
--   NOUNPACK #-}</tt> explicitly.
--   
--   Under the hood 'atomicModifyMutVar2#' atomically replaces a pointer to
--   an old <tt>x :: a</tt> with a pointer to a selector thunk <tt>fst
--   r</tt>, where <tt>fst</tt> is a selector for the first field of the
--   record and <tt>r</tt> is a function application thunk <tt>r = f
--   x</tt>.
--   
--   <tt>atomicModifyIORef2Native</tt> from <tt>atomic-modify-general</tt>
--   package makes an effort to reflect restrictions on <tt>c</tt>
--   faithfully, providing a well-typed high-level wrapper.
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)

-- | Modify the contents of a 'MutVar#', returning the previous contents
--   and the result of applying the given function to the previous
--   contents.
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)

-- | Given an array and an offset in machine words, read an element. The
--   index is assumed to be in bounds. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicReadIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, read a machine word. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicReadWordAddr# :: Addr# -> State# d -> (# State# d, Word# #)

-- | Atomically exchange the value of a 'MutVar#'.
atomicSwapMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> State# d -> (# State# d, a #)

-- | Given an array and an offset in machine words, write an element. The
--   index is assumed to be in bounds. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicWriteIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Given an address, write a machine word. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicWriteWordAddr# :: Addr# -> Word# -> State# d -> State# d
atomically# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | Reverse the order of the bits in a word.
bitReverse# :: Word# -> Word#

-- | Reverse the order of the bits in a 16-bit word.
bitReverse16# :: Word# -> Word#

-- | Reverse the order of the bits in a 32-bit word.
bitReverse32# :: Word# -> Word#

-- | Reverse the order of the bits in a 64-bit word.
bitReverse64# :: Word64# -> Word64#

-- | Reverse the order of the bits in a 8-bit word.
bitReverse8# :: Word# -> Word#

-- | Broadcast a scalar to all elements of a vector.
broadcastDoubleX2# :: Double# -> DoubleX2#

-- | Broadcast a scalar to all elements of a vector.
broadcastDoubleX4# :: Double# -> DoubleX4#

-- | Broadcast a scalar to all elements of a vector.
broadcastDoubleX8# :: Double# -> DoubleX8#

-- | Broadcast a scalar to all elements of a vector.
broadcastFloatX16# :: Float# -> FloatX16#

-- | Broadcast a scalar to all elements of a vector.
broadcastFloatX4# :: Float# -> FloatX4#

-- | Broadcast a scalar to all elements of a vector.
broadcastFloatX8# :: Float# -> FloatX8#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt16X16# :: Int16# -> Int16X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt16X32# :: Int16# -> Int16X32#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt16X8# :: Int16# -> Int16X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt32X16# :: Int32# -> Int32X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt32X4# :: Int32# -> Int32X4#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt32X8# :: Int32# -> Int32X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt64X2# :: Int64# -> Int64X2#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt64X4# :: Int64# -> Int64X4#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt64X8# :: Int64# -> Int64X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt8X16# :: Int8# -> Int8X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt8X32# :: Int8# -> Int8X32#

-- | Broadcast a scalar to all elements of a vector.
broadcastInt8X64# :: Int8# -> Int8X64#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord16X16# :: Word16# -> Word16X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord16X32# :: Word16# -> Word16X32#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord16X8# :: Word16# -> Word16X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord32X16# :: Word32# -> Word32X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord32X4# :: Word32# -> Word32X4#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord32X8# :: Word32# -> Word32X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord64X2# :: Word64# -> Word64X2#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord64X4# :: Word64# -> Word64X4#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord64X8# :: Word64# -> Word64X8#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord8X16# :: Word8# -> Word8X16#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord8X32# :: Word8# -> Word8X32#

-- | Broadcast a scalar to all elements of a vector.
broadcastWord8X64# :: Word8# -> Word8X64#

-- | Intended for use with pinned arrays; otherwise very unsafe!
byteArrayContents# :: ByteArray# -> Addr#

-- | Swap bytes in a word.
byteSwap# :: Word# -> Word#

-- | Swap bytes in the lower 16 bits of a word. The higher bytes are
--   undefined.
byteSwap16# :: Word# -> Word#

-- | Swap bytes in the lower 32 bits of a word. The higher bytes are
--   undefined.
byteSwap32# :: Word# -> Word#

-- | Swap bytes in a 64 bits of a word.
byteSwap64# :: Word64# -> Word64#

-- | Given an array, an offset, the expected old value, and the new value,
--   perform an atomic compare and swap (i.e. write the new value if the
--   current value and the old value are the same pointer). Returns 0 if
--   the swap succeeds and 1 if it fails. Additionally, returns the element
--   at the offset after the operation completes. This means that on a
--   success the new value is returned, and on a failure the actual old
--   value (not the expected one) is returned. Implies a full memory
--   barrier. The use of a pointer equality on a boxed value makes this
--   function harder to use correctly than 'casIntArray#'. All of the
--   difficulties of using 'reallyUnsafePtrEquality#' correctly apply to
--   'casArray#' as well.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)

-- | Given an array, an offset in 16 bit units, the expected old value, and
--   the new value, perform an atomic compare and swap i.e. write the new
--   value if the current value matches the provided old value. Returns the
--   value of the element before the operation. Implies a full memory
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casInt16Array# :: MutableByteArray# d -> Int# -> Int16# -> Int16# -> State# d -> (# State# d, Int16# #)

-- | Given an array, an offset in 32 bit units, the expected old value, and
--   the new value, perform an atomic compare and swap i.e. write the new
--   value if the current value matches the provided old value. Returns the
--   value of the element before the operation. Implies a full memory
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casInt32Array# :: MutableByteArray# d -> Int# -> Int32# -> Int32# -> State# d -> (# State# d, Int32# #)

-- | Given an array, an offset in 64 bit units, the expected old value, and
--   the new value, perform an atomic compare and swap i.e. write the new
--   value if the current value matches the provided old value. Returns the
--   value of the element before the operation. Implies a full memory
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casInt64Array# :: MutableByteArray# d -> Int# -> Int64# -> Int64# -> State# d -> (# State# d, Int64# #)

-- | Given an array, an offset in bytes, the expected old value, and the
--   new value, perform an atomic compare and swap i.e. write the new value
--   if the current value matches the provided old value. Returns the value
--   of the element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casInt8Array# :: MutableByteArray# d -> Int# -> Int8# -> Int8# -> State# d -> (# State# d, Int8# #)

-- | Given an array, an offset in machine words, the expected old value,
--   and the new value, perform an atomic compare and swap i.e. write the
--   new value if the current value matches the provided old value. Returns
--   the value of the element before the operation. Implies a full memory
--   barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casIntArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Compare-and-swap: perform a pointer equality test between the first
--   value passed to this function and the value stored inside the
--   'MutVar#'. If the pointers are equal, replace the stored value with
--   the second value passed to this function, otherwise do nothing.
--   Returns the final value stored inside the 'MutVar#'. The 'Int#'
--   indicates whether a swap took place, with <tt>1#</tt> meaning that we
--   didn't swap, and <tt>0#</tt> that we did. Implies a full memory
--   barrier. Because the comparison is done on the level of pointers, all
--   of the difficulties of using 'reallyUnsafePtrEquality#' correctly
--   apply to 'casMutVar#' as well.
casMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)

-- | Unsafe, machine-level atomic compare and swap on an element within an
--   array. See the documentation of 'casArray#'.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)

-- | Bitcast a 'Double#' into a 'Word64#'
castDoubleToWord64# :: Double# -> Word64#

-- | Bitcast a 'Float#' into a 'Word32#'
castFloatToWord32# :: Float# -> Word32#

-- | Bitcast a 'Word32#' into a 'Float#'
castWord32ToFloat# :: Word32# -> Float#

-- | Bitcast a 'Word64#' into a 'Double#'
castWord64ToDouble# :: Word64# -> Double#

-- | <tt>'catch#' k handler s</tt> evaluates <tt>k s</tt>, invoking
--   <tt>handler</tt> on any exceptions thrown.
--   
--   Note that the result type here isn't quite as unrestricted as the
--   polymorphic type might suggest; see the section "RuntimeRep
--   polymorphism in continuation-style primops" for details.
catch# :: forall {q :: RuntimeRep} {k :: Levity} (a :: TYPE q) (b :: TYPE ('BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchRetry# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchSTM# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
chr# :: Int# -> Char#

-- | Run the supplied IO action with an empty CCS. For example, this is
--   used by the interpreter to run an interpreted computation without the
--   call stack showing that it was invoked from GHC.
clearCCS# :: (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int# -> Int# -> Array# a

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int# -> Int# -> SmallArray# a

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | <tt>'closureSize#' closure</tt> returns the size of the given closure
--   in machine words.
closureSize# :: a -> Int#

-- | Count leading zeros in a word.
clz# :: Word# -> Word#

-- | Count leading zeros in the lower 16 bits of a word.
clz16# :: Word# -> Word#

-- | Count leading zeros in the lower 32 bits of a word.
clz32# :: Word# -> Word#

-- | Count leading zeros in a 64-bit word.
clz64# :: Word64# -> Word#

-- | Count leading zeros in the lower 8 bits of a word.
clz8# :: Word# -> Word#

-- | The function <tt>coerce</tt> allows you to safely convert between
--   values of types that have the same representation with no run-time
--   overhead. In the simplest case you can use it instead of a newtype
--   constructor, to go from the newtype's concrete type to the abstract
--   type. But it also works in more complicated settings, e.g. converting
--   a list of newtypes to a list of concrete types.
--   
--   When used in conversions involving a newtype wrapper, make sure the
--   newtype constructor is in scope.
--   
--   This function is representation-polymorphic, but the
--   <tt>RuntimeRep</tt> type argument is marked as <tt>Inferred</tt>,
--   meaning that it is not available for visible type application. This
--   means the typechecker will accept <tt><tt>coerce</tt> @<tt>Int</tt>
--   @Age 42</tt>.
--   
--   <h3><b>Examples</b></h3>
--   
--   <pre>
--   &gt;&gt;&gt; newtype TTL = TTL Int deriving (Eq, Ord, Show)
--   
--   &gt;&gt;&gt; newtype Age = Age Int deriving (Eq, Ord, Show)
--   
--   &gt;&gt;&gt; coerce (Age 42) :: TTL
--   TTL 42
--   
--   &gt;&gt;&gt; coerce (+ (1 :: Int)) (Age 42) :: TTL
--   TTL 43
--   
--   &gt;&gt;&gt; coerce (map (+ (1 :: Int))) [Age 42, Age 24] :: [TTL]
--   [TTL 43,TTL 25]
--   </pre>
coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

-- | Recursively add a closure and its transitive closure to a 'Compact#'
--   (a CNF), evaluating any unevaluated components at the same time. Note:
--   'compactAdd#' is not thread-safe, so only one thread may call
--   'compactAdd#' with a particular 'Compact#' at any given time. The
--   primop does not enforce any mutual exclusion; the caller is expected
--   to arrange this.
compactAdd# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Like 'compactAdd#', but retains sharing and cycles during compaction.
compactAddWithSharing# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Attempt to allocate a compact block with the capacity (in bytes) given
--   by the first argument. The 'Addr#' is a pointer to previous compact
--   block of the CNF or 'nullAddr#' to create a new CNF with a single
--   compact block.
--   
--   The resulting block is not known to the GC until
--   'compactFixupPointers#' is called on it, and care must be taken so
--   that the address does not escape or memory will be leaked.
compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)

-- | Returns 1# if the object is contained in the CNF, 0# otherwise.
compactContains# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)

-- | Returns 1# if the object is in any CNF at all, 0# otherwise.
compactContainsAny# :: a -> State# RealWorld -> (# State# RealWorld, Int# #)

-- | Given the pointer to the first block of a CNF and the address of the
--   root object in the old address space, fix up the internal pointers
--   inside the CNF to account for a different position in memory than when
--   it was serialized. This method must be called exactly once after
--   importing a serialized CNF. It returns the new CNF and the new
--   adjusted root address.
compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)

-- | Returns the address and the utilized size (in bytes) of the first
--   compact block of a CNF.
compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)

-- | Given a CNF and the address of one its compact blocks, returns the
--   next compact block and its utilized size, or 'nullAddr#' if the
--   argument was the last compact block in the CNF.
compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)

-- | Create a new CNF with a single compact block. The argument is the
--   capacity of the compact block (in bytes, not words). The capacity is
--   rounded up to a multiple of the allocator block size and is capped to
--   one mega block.
compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)

-- | Set the new allocation size of the CNF. This value (in bytes)
--   determines the capacity of each compact block in the CNF. It does not
--   retroactively affect existing compact blocks in the CNF.
compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld

-- | Return the total capacity (in bytes) of all the compact blocks in the
--   CNF.
compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)

-- | <tt>'compareByteArrays#' src1 src1_ofs src2 src2_ofs n</tt> compares
--   <tt>n</tt> bytes starting at offset <tt>src1_ofs</tt> in the first
--   'ByteArray#' <tt>src1</tt> to the range of <tt>n</tt> bytes (i.e. same
--   length) starting at offset <tt>src2_ofs</tt> of the second
--   'ByteArray#' <tt>src2</tt>. Both arrays must fully contain the
--   specified ranges, but this is not checked. Returns an 'Int#' less
--   than, equal to, or greater than zero if the range is found,
--   respectively, to be byte-wise lexicographically less than, to match,
--   or be greater than the second range.
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#

-- | See <a>GHC.Prim#continuations</a>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
control0# :: forall {r :: RuntimeRep} a (b :: TYPE r). PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)

-- | <tt>'copyAddrToAddr#' src dest len</tt> copies <tt>len</tt> bytes from
--   <tt>src</tt> to <tt>dest</tt>. These two memory ranges are allowed to
--   overlap.
--   
--   Analogous to the standard C function <tt>memmove</tt>, but with a
--   different argument order.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld

-- | <tt>'copyAddrToAddrNonOverlapping#' src dest len</tt> copies
--   <tt>len</tt> bytes from <tt>src</tt> to <tt>dest</tt>. As the name
--   suggests, these two memory ranges <i>must not overlap</i>, although
--   this pre-condition is not checked.
--   
--   Analogous to the standard C function <tt>memcpy</tt>, but with a
--   different argument order.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld

-- | Copy a memory range starting at the Addr# to the specified range in
--   the MutableByteArray#. The memory region at Addr# and the ByteArray#
--   must fully contain the specified ranges, but this is not checked. The
--   Addr# must not point into the MutableByteArray# (e.g. if the
--   MutableByteArray# were pinned), but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyAddrToByteArray# :: Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. Both arrays must fully contain the specified ranges, but this
--   is not checked. The two arrays must not be the same array in different
--   states, but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | <tt>'copyByteArray#' src src_ofs dst dst_ofs len</tt> copies the range
--   starting at offset <tt>src_ofs</tt> of length <tt>len</tt> from the
--   'ByteArray#' <tt>src</tt> to the 'MutableByteArray#' <tt>dst</tt>
--   starting at offset <tt>dst_ofs</tt>. Both arrays must fully contain
--   the specified ranges, but this is not checked. The two arrays must not
--   be the same array in different states, but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Copy a range of the ByteArray# to the memory range starting at the
--   Addr#. The ByteArray# and the memory region at Addr# must fully
--   contain the specified ranges, but this is not checked. The Addr# must
--   not point into the ByteArray# (e.g. if the ByteArray# were pinned),
--   but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. Both arrays must fully contain the specified ranges, but this
--   is not checked. In the case where the source and destination are the
--   same array the source and destination regions may overlap.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | <tt>'copyMutableByteArray#' src src_ofs dst dst_ofs len</tt> copies
--   the range starting at offset <tt>src_ofs</tt> of length <tt>len</tt>
--   from the 'MutableByteArray#' <tt>src</tt> to the 'MutableByteArray#'
--   <tt>dst</tt> starting at offset <tt>dst_ofs</tt>. Both arrays must
--   fully contain the specified ranges, but this is not checked. The
--   regions are allowed to overlap, although this is only possible when
--   the same array is provided as both the source and the destination.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableByteArray# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <tt>'copyMutableByteArrayNonOverlapping#' src src_ofs dst dst_ofs
--   len</tt> copies the range starting at offset <tt>src_ofs</tt> of
--   length <tt>len</tt> from the 'MutableByteArray#' <tt>src</tt> to the
--   'MutableByteArray#' <tt>dst</tt> starting at offset <tt>dst_ofs</tt>.
--   Both arrays must fully contain the specified ranges, but this is not
--   checked. The regions are <i>not</i> allowed to overlap, but this is
--   also not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableByteArrayNonOverlapping# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Copy a range of the MutableByteArray# to the memory range starting at
--   the Addr#. The MutableByteArray# and the memory region at Addr# must
--   fully contain the specified ranges, but this is not checked. The Addr#
--   must not point into the MutableByteArray# (e.g. if the
--   MutableByteArray# were pinned), but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableByteArrayToAddr# :: MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. Both arrays must fully contain the specified ranges, but this
--   is not checked. The two arrays must not be the same array in different
--   states, but this is not checked either.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copySmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. The source and destination arrays can refer to the same array.
--   Both arrays must fully contain the specified ranges, but this is not
--   checked. The regions are allowed to overlap, although this is only
--   possible when the same array is provided as both the source and the
--   destination.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copySmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
cosDouble# :: Double# -> Double#
cosFloat# :: Float# -> Float#
coshDouble# :: Double# -> Double#
coshFloat# :: Float# -> Float#

-- | Count trailing zeros in a word.
ctz# :: Word# -> Word#

-- | Count trailing zeros in the lower 16 bits of a word.
ctz16# :: Word# -> Word#

-- | Count trailing zeros in the lower 32 bits of a word.
ctz32# :: Word# -> Word#

-- | Count trailing zeros in a 64-bit word.
ctz64# :: Word64# -> Word#

-- | Count trailing zeros in the lower 8 bits of a word.
ctz8# :: Word# -> Word#
deRefStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
deRefWeak# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)

-- | Convert to integer. First component of the result is -1 or 1,
--   indicating the sign of the mantissa. The next two are the high and low
--   32 bits of the mantissa respectively, and the last is the exponent.
decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)

-- | Decode 'Double#' into mantissa and base-2 exponent.
decodeDouble_Int64# :: Double# -> (# Int64#, Int# #)

-- | Convert to integers. First 'Int#' in result is the mantissa; second is
--   the exponent.
decodeFloat_Int# :: Float# -> (# Int#, Int# #)

-- | Sleep specified number of microseconds.
delay# :: Int# -> State# d -> State# d

-- | Divide two vectors element-wise.
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Divide two vectors element-wise.
divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Divide two vectors element-wise.
divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
divideFloat# :: Float# -> Float# -> Float#

-- | Divide two vectors element-wise.
divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Divide two vectors element-wise.
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Divide two vectors element-wise.
divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
double2Float# :: Double# -> Float#

-- | Truncates a 'Double#' value to the nearest 'Int#'. Results are
--   undefined if the truncation if truncation yields a value outside the
--   range of 'Int#'.
double2Int# :: Double# -> Int#
eqAddr# :: Addr# -> Addr# -> Int#
eqChar# :: Char# -> Char# -> Int#
eqFloat# :: Float# -> Float# -> Int#
eqInt16# :: Int16# -> Int16# -> Int#
eqInt32# :: Int32# -> Int32# -> Int#
eqInt64# :: Int64# -> Int64# -> Int#
eqInt8# :: Int8# -> Int8# -> Int#
eqStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StablePtr# a -> StablePtr# a -> Int#
eqWord# :: Word# -> Word# -> Int#
eqWord16# :: Word16# -> Word16# -> Int#
eqWord32# :: Word32# -> Word32# -> Int#
eqWord64# :: Word64# -> Word64# -> Int#
eqWord8# :: Word8# -> Word8# -> Int#
expDouble# :: Double# -> Double#
expFloat# :: Float# -> Float#
expm1Double# :: Double# -> Double#
expm1Float# :: Float# -> Float#
fabsDouble# :: Double# -> Double#
fabsFloat# :: Float# -> Float#

-- | Given an array, and offset in machine words, and a value to add,
--   atomically add the value to the element. Returns the value of the
--   element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAddIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to add, atomically add the value to the
--   element. Returns the value of the element before the operation.
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAddWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Given an array, and offset in machine words, and a value to AND,
--   atomically AND the value into the element. Returns the value of the
--   element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAndIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to AND, atomically AND the value into
--   the element. Returns the value of the element before the operation.
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAndWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Given an array, and offset in machine words, and a value to NAND,
--   atomically NAND the value into the element. Returns the value of the
--   element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchNandIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to NAND, atomically NAND the value into
--   the element. Returns the value of the element before the operation.
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchNandWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Given an array, and offset in machine words, and a value to OR,
--   atomically OR the value into the element. Returns the value of the
--   element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchOrIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to OR, atomically OR the value into the
--   element. Returns the value of the element before the operation.
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchOrWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Given an array, and offset in machine words, and a value to subtract,
--   atomically subtract the value from the element. Returns the value of
--   the element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchSubIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to subtract, atomically subtract the
--   value from the element. Returns the value of the element before the
--   operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchSubWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Given an array, and offset in machine words, and a value to XOR,
--   atomically XOR the value into the element. Returns the value of the
--   element before the operation. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchXorIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an address, and a value to XOR, atomically XOR the value into
--   the element. Returns the value of the element before the operation.
--   Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchXorWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)

-- | Finalize a weak pointer. The return value is an unboxed tuple
--   containing the new state of the world and an "unboxed Maybe",
--   represented by an 'Int#' and a (possibly invalid) finalization action.
--   An 'Int#' of <tt>1</tt> indicates that the finalizer is valid. The
--   return value <tt>b</tt> from the finalizer should be ignored.
finalizeWeak# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
float2Double# :: Float# -> Double#

-- | Truncates a 'Float#' value to the nearest 'Int#'. Results are
--   undefined if the truncation if truncation yields a value outside the
--   range of 'Int#'.
float2Int# :: Float# -> Int#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddDouble# :: Double# -> Double# -> Double# -> Double#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddFloat# :: Float# -> Float# -> Float# -> Float#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#

-- | Fused multiply-add operation <tt>x*y+z</tt>. See <a>GHC.Prim#fma</a>.
fmaddFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubDouble# :: Double# -> Double# -> Double# -> Double#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubFloat# :: Float# -> Float# -> Float# -> Float#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#

-- | Fused multiply-subtract operation <tt>x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fmsubFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddDouble# :: Double# -> Double# -> Double# -> Double#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddFloat# :: Float# -> Float# -> Float# -> Float#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#

-- | Fused negate-multiply-add operation <tt>-x*y+z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmaddFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubDouble# :: Double# -> Double# -> Double# -> Double#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubFloat# :: Float# -> Float# -> Float# -> Float#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#

-- | Fused negate-multiply-subtract operation <tt>-x*y-z</tt>. See
--   <a>GHC.Prim#fma</a>.
fnmsubFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#
fork# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
forkOn# :: forall {q :: RuntimeRep} (a :: TYPE q). Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
freezeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
freezeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
geAddr# :: Addr# -> Addr# -> Int#
geChar# :: Char# -> Char# -> Int#
geFloat# :: Float# -> Float# -> Int#
geInt16# :: Int16# -> Int16# -> Int#
geInt32# :: Int32# -> Int32# -> Int#
geInt64# :: Int64# -> Int64# -> Int#
geInt8# :: Int8# -> Int8# -> Int#
geWord# :: Word# -> Word# -> Int#
geWord16# :: Word16# -> Word16# -> Int#
geWord32# :: Word32# -> Word32# -> Int#
geWord64# :: Word64# -> Word64# -> Int#
geWord8# :: Word8# -> Word8# -> Int#
getApStackVal# :: a -> Int# -> (# Int#, b #)
getCCSOf# :: a -> State# d -> (# State# d, Addr# #)

-- | Returns the current <tt>CostCentreStack</tt> (value is <tt>NULL</tt>
--   if not profiling). Takes a dummy argument which can be used to avoid
--   the call to 'getCurrentCCS#' being floated out by the simplifier,
--   which would result in an uninformative stack (<a>CAF</a>).
getCurrentCCS# :: a -> State# d -> (# State# d, Addr# #)
getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)

-- | Return the number of elements in the array, correctly accounting for
--   the effect of 'shrinkMutableByteArray#' and 'resizeMutableByteArray#'.
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)

-- | Return the number of elements in the array, correctly accounting for
--   the effect of 'shrinkSmallMutableArray#' and
--   <tt>resizeSmallMutableArray#</tt>.
getSizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
getSpark# :: State# d -> (# State# d, Int#, a #)
gtAddr# :: Addr# -> Addr# -> Int#
gtChar# :: Char# -> Char# -> Int#
gtFloat# :: Float# -> Float# -> Int#
gtInt16# :: Int16# -> Int16# -> Int#
gtInt32# :: Int32# -> Int32# -> Int#
gtInt64# :: Int64# -> Int64# -> Int#
gtInt8# :: Int8# -> Int8# -> Int#
gtWord# :: Word# -> Word# -> Int#
gtWord16# :: Word16# -> Word16# -> Int#
gtWord32# :: Word32# -> Word32# -> Int#
gtWord64# :: Word64# -> Word64# -> Int#
gtWord8# :: Word8# -> Word8# -> Int#

-- | Read a machine address from immutable array; offset in machine words.
indexAddrArray# :: ByteArray# -> Int# -> Addr#

-- | Read a machine address from immutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexAddrOffAddr# :: Addr# -> Int# -> Addr#

-- | Read from the specified index of an immutable array. The result is
--   packaged into an unboxed unary tuple; the result itself is not yet
--   evaluated. Pattern matching on the tuple forces the indexing of the
--   array to happen but does not evaluate the element itself. Evaluating
--   the thunk prevents additional thunks from building up on the heap.
--   Avoiding these thunks, in turn, reduces references to the argument
--   array, allowing it to be garbage collected more promptly.
indexArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int# -> (# a #)

-- | Read an 8-bit character from immutable array; offset in bytes.
indexCharArray# :: ByteArray# -> Int# -> Char#

-- | Read an 8-bit character from immutable address; offset in bytes.
indexCharOffAddr# :: Addr# -> Int# -> Char#

-- | Read a double-precision floating-point value from immutable array;
--   offset in 8-byte words.
indexDoubleArray# :: ByteArray# -> Int# -> Double#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#

-- | Read a double-precision floating-point value from immutable address;
--   offset in 8-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexDoubleOffAddr# :: Addr# -> Int# -> Double#

-- | Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#

-- | Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#

-- | Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#

-- | Read a single-precision floating-point value from immutable array;
--   offset in 4-byte words.
indexFloatArray# :: ByteArray# -> Int# -> Float#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#

-- | Read a single-precision floating-point value from immutable address;
--   offset in 4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexFloatOffAddr# :: Addr# -> Int# -> Float#

-- | Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#

-- | Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#

-- | Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#

-- | Read a 16-bit signed integer from immutable array; offset in 2-byte
--   words.
indexInt16Array# :: ByteArray# -> Int# -> Int16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#

-- | Read a 16-bit signed integer from immutable address; offset in 2-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexInt16OffAddr# :: Addr# -> Int# -> Int16#

-- | Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#

-- | Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#

-- | Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#

-- | Read a 32-bit signed integer from immutable array; offset in 4-byte
--   words.
indexInt32Array# :: ByteArray# -> Int# -> Int32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#

-- | Read a 32-bit signed integer from immutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexInt32OffAddr# :: Addr# -> Int# -> Int32#

-- | Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#

-- | Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#

-- | Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#

-- | Read a 64-bit signed integer from immutable array; offset in 8-byte
--   words.
indexInt64Array# :: ByteArray# -> Int# -> Int64#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#

-- | Read a 64-bit signed integer from immutable address; offset in 8-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexInt64OffAddr# :: Addr# -> Int# -> Int64#

-- | Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#

-- | Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#

-- | Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#

-- | Read an 8-bit signed integer from immutable array; offset in bytes.
indexInt8Array# :: ByteArray# -> Int# -> Int8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#

-- | Read an 8-bit signed integer from immutable address; offset in bytes.
indexInt8OffAddr# :: Addr# -> Int# -> Int8#

-- | Reads vector; offset in scalar elements.
indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#

-- | Reads vector; offset in scalar elements.
indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#

-- | Reads vector; offset in scalar elements.
indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#

-- | Read a word-sized integer from immutable array; offset in machine
--   words.
indexIntArray# :: ByteArray# -> Int# -> Int#

-- | Read a word-sized integer from immutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexIntOffAddr# :: Addr# -> Int# -> Int#

-- | Read from specified index of immutable array. Result is packaged into
--   an unboxed singleton; the result itself is not yet evaluated.
indexSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int# -> (# a #)

-- | Read a 'StablePtr#' value from immutable array; offset in machine
--   words.
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a

-- | Read a 'StablePtr#' value from immutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a

-- | Read a 32-bit character from immutable array; offset in 4-byte words.
indexWideCharArray# :: ByteArray# -> Int# -> Char#

-- | Read a 32-bit character from immutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexWideCharOffAddr# :: Addr# -> Int# -> Char#

-- | Read a 16-bit unsigned integer from immutable array; offset in 2-byte
--   words.
indexWord16Array# :: ByteArray# -> Int# -> Word16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#

-- | Read a 16-bit unsigned integer from immutable address; offset in
--   2-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexWord16OffAddr# :: Addr# -> Int# -> Word16#

-- | Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#

-- | Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#

-- | Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#

-- | Read a 32-bit unsigned integer from immutable array; offset in 4-byte
--   words.
indexWord32Array# :: ByteArray# -> Int# -> Word32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#

-- | Read a 32-bit unsigned integer from immutable address; offset in
--   4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexWord32OffAddr# :: Addr# -> Int# -> Word32#

-- | Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#

-- | Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#

-- | Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#

-- | Read a 64-bit unsigned integer from immutable array; offset in 8-byte
--   words.
indexWord64Array# :: ByteArray# -> Int# -> Word64#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#

-- | Read a 64-bit unsigned integer from immutable address; offset in
--   8-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexWord64OffAddr# :: Addr# -> Int# -> Word64#

-- | Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#

-- | Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#

-- | Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#

-- | Read an 8-bit unsigned integer from immutable array; offset in bytes.
indexWord8Array# :: ByteArray# -> Int# -> Word8#

-- | Read a machine address from immutable array; offset in bytes.
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#

-- | Read an 8-bit character from immutable array; offset in bytes.
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#

-- | Read a double-precision floating-point value from immutable array;
--   offset in bytes.
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#

-- | Read a single-precision floating-point value from immutable array;
--   offset in bytes.
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#

-- | Read a word-sized integer from immutable array; offset in bytes.
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#

-- | Read a 16-bit signed integer from immutable array; offset in bytes.
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#

-- | Read a 32-bit signed integer from immutable array; offset in bytes.
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#

-- | Read a 64-bit signed integer from immutable array; offset in bytes.
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#

-- | Read a 'StablePtr#' value from immutable array; offset in bytes.
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a

-- | Read a 32-bit character from immutable array; offset in bytes.
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#

-- | Read a word-sized unsigned integer from immutable array; offset in
--   bytes.
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#

-- | Read a 16-bit unsigned integer from immutable array; offset in bytes.
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#

-- | Read a 32-bit unsigned integer from immutable array; offset in bytes.
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#

-- | Read a 64-bit unsigned integer from immutable array; offset in bytes.
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#

-- | Read an 8-bit unsigned integer from immutable address; offset in
--   bytes.
indexWord8OffAddr# :: Addr# -> Int# -> Word8#

-- | Read a machine address from immutable address; offset in bytes.
indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#

-- | Read an 8-bit character from immutable address; offset in bytes.
indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#

-- | Read a double-precision floating-point value from immutable address;
--   offset in bytes.
indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#

-- | Read a single-precision floating-point value from immutable address;
--   offset in bytes.
indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#

-- | Read a word-sized integer from immutable address; offset in bytes.
indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#

-- | Read a 16-bit signed integer from immutable address; offset in bytes.
indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#

-- | Read a 32-bit signed integer from immutable address; offset in bytes.
indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#

-- | Read a 64-bit signed integer from immutable address; offset in bytes.
indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#

-- | Read a 'StablePtr#' value from immutable address; offset in bytes.
indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a

-- | Read a 32-bit character from immutable address; offset in bytes.
indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#

-- | Read a word-sized unsigned integer from immutable address; offset in
--   bytes.
indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#

-- | Read a 16-bit unsigned integer from immutable address; offset in
--   bytes.
indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#

-- | Read a 32-bit unsigned integer from immutable address; offset in
--   bytes.
indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#

-- | Read a 64-bit unsigned integer from immutable address; offset in
--   bytes.
indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#

-- | Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#

-- | Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#

-- | Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#

-- | Read a vector from the specified index of an immutable array. The
--   index is counted in units of SIMD vectors (not scalar elements).
indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#

-- | Read a word-sized unsigned integer from immutable array; offset in
--   machine words.
indexWordArray# :: ByteArray# -> Int# -> Word#

-- | Read a word-sized unsigned integer from immutable address; offset in
--   machine words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
indexWordOffAddr# :: Addr# -> Int# -> Word#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt16X16# :: Int16X16# -> Int16# -> Int# -> Int16X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt16X32# :: Int16X32# -> Int16# -> Int# -> Int16X32#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt16X8# :: Int16X8# -> Int16# -> Int# -> Int16X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt32X16# :: Int32X16# -> Int32# -> Int# -> Int32X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt32X4# :: Int32X4# -> Int32# -> Int# -> Int32X4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt32X8# :: Int32X8# -> Int32# -> Int# -> Int32X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt64X2# :: Int64X2# -> Int64# -> Int# -> Int64X2#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt64X4# :: Int64X4# -> Int64# -> Int# -> Int64X4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt64X8# :: Int64X8# -> Int64# -> Int# -> Int64X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt8X16# :: Int8X16# -> Int8# -> Int# -> Int8X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt8X32# :: Int8X32# -> Int8# -> Int# -> Int8X32#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertInt8X64# :: Int8X64# -> Int8# -> Int# -> Int8X64#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord16X16# :: Word16X16# -> Word16# -> Int# -> Word16X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord16X32# :: Word16X32# -> Word16# -> Int# -> Word16X32#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord16X8# :: Word16X8# -> Word16# -> Int# -> Word16X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord32X16# :: Word32X16# -> Word32# -> Int# -> Word32X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord32X4# :: Word32X4# -> Word32# -> Int# -> Word32X4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord32X8# :: Word32X8# -> Word32# -> Int# -> Word32X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord64X2# :: Word64X2# -> Word64# -> Int# -> Word64X2#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord64X4# :: Word64X4# -> Word64# -> Int# -> Word64X4#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord64X8# :: Word64X8# -> Word64# -> Int# -> Word64X8#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord8X16# :: Word8X16# -> Word8# -> Int# -> Word8X16#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord8X32# :: Word8X32# -> Word8# -> Int# -> Word8X32#

-- | Insert a scalar at the given position in a vector. The position must
--   be a compile-time constant.
insertWord8X64# :: Word8X64# -> Word8# -> Int# -> Word8X64#
int16ToInt# :: Int16# -> Int#
int16ToWord16# :: Int16# -> Word16#

-- | Coerce directly from int to address. Users are discouraged from using
--   this operation as it makes little sense on platforms with tagged
--   pointers.
int2Addr# :: Int# -> Addr#

-- | Convert an 'Int#' to the corresponding 'Double#' with the same
--   integral value (up to truncation due to floating-point precision).
--   e.g. <tt>'int2Double#' 1# == 1.0##</tt>
int2Double# :: Int# -> Double#

-- | Convert an 'Int#' to the corresponding 'Float#' with the same integral
--   value (up to truncation due to floating-point precision). e.g.
--   <tt>'int2Float#' 1# == 1.0#</tt>
int2Float# :: Int# -> Float#
int2Word# :: Int# -> Word#
int32ToInt# :: Int32# -> Int#
int32ToWord32# :: Int32# -> Word32#
int64ToInt# :: Int64# -> Int#
int64ToWord64# :: Int64# -> Word64#
int8ToInt# :: Int8# -> Int#
int8ToWord8# :: Int8# -> Word8#
intToInt16# :: Int# -> Int16#
intToInt32# :: Int# -> Int32#
intToInt64# :: Int# -> Int64#
intToInt8# :: Int# -> Int8#

-- | Determine whether a 'ByteArray#' is guaranteed not to move.
isByteArrayPinned# :: ByteArray# -> Int#

-- | Similar to 'isByteArrayPinned#'. Weakly pinned byte arrays are allowed
--   to be copied into compact regions by the user, potentially
--   invalidating the results of earlier calls to 'byteArrayContents#'.
--   
--   See the section `Pinned Byte Arrays` in the user guide for more
--   information.
--   
--   This function also returns true for regular pinned bytearrays.
isByteArrayWeaklyPinned# :: ByteArray# -> Int#
isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)

-- | Return 1 if 'MVar#' is empty; 0 otherwise.
isEmptyMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int# #)

-- | Determine whether a 'MutableByteArray#' is guaranteed not to move
--   during GC.
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#

-- | 'isByteArrayWeaklyPinned#' but for mutable arrays.
isMutableByteArrayWeaklyPinned# :: MutableByteArray# d -> Int#

-- | <tt>'keepAlive#' x s k</tt> keeps the value <tt>x</tt> alive during
--   the execution of the computation <tt>k</tt>.
--   
--   Note that the result type here isn't quite as unrestricted as the
--   polymorphic type might suggest; see the section "RuntimeRep
--   polymorphism in continuation-style primops" for details.
keepAlive# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) d (b :: TYPE r). a -> State# d -> (State# d -> b) -> b
killThread# :: ThreadId# -> a -> State# RealWorld -> State# RealWorld

-- | Set the label of the given thread. The <tt>ByteArray#</tt> should
--   contain a UTF-8-encoded string.
labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
leAddr# :: Addr# -> Addr# -> Int#
leChar# :: Char# -> Char# -> Int#
leFloat# :: Float# -> Float# -> Int#
leInt16# :: Int16# -> Int16# -> Int#
leInt32# :: Int32# -> Int32# -> Int#
leInt64# :: Int64# -> Int64# -> Int#
leInt8# :: Int8# -> Int8# -> Int#
leWord# :: Word# -> Word# -> Int#
leWord16# :: Word16# -> Word16# -> Int#
leWord32# :: Word32# -> Word32# -> Int#
leWord64# :: Word64# -> Word64# -> Int#
leWord8# :: Word8# -> Word8# -> Int#
leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {n :: Multiplicity} (a :: TYPE q) (b :: TYPE r). (a %n -> b) -> a %n -> b

-- | Returns an array of the threads started by the program. Note that this
--   threads which have finished execution may or may not be present in
--   this list, depending upon whether they have been collected by the
--   garbage collector.
listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
log1pDouble# :: Double# -> Double#
log1pFloat# :: Float# -> Float#
logDouble# :: Double# -> Double#
logFloat# :: Float# -> Float#
ltAddr# :: Addr# -> Addr# -> Int#
ltChar# :: Char# -> Char# -> Int#
ltFloat# :: Float# -> Float# -> Int#
ltInt16# :: Int16# -> Int16# -> Int#
ltInt32# :: Int32# -> Int32# -> Int#
ltInt64# :: Int64# -> Int64# -> Int#
ltInt8# :: Int8# -> Int8# -> Int#
ltWord# :: Word# -> Word# -> Int#
ltWord16# :: Word16# -> Word16# -> Int#
ltWord32# :: Word32# -> Word32# -> Int#
ltWord64# :: Word64# -> Word64# -> Int#
ltWord8# :: Word8# -> Word8# -> Int#
makeStableName# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
makeStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)

-- | <tt>'maskAsyncExceptions#' k s</tt> evaluates <tt>k s</tt> such that
--   asynchronous exceptions are deferred until after evaluation has
--   finished.
--   
--   Note that the result type here isn't quite as unrestricted as the
--   polymorphic type might suggest; see the section "RuntimeRep
--   polymorphism in continuation-style primops" for details.
maskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | <tt>'maskUninterruptible#' k s</tt> evaluates <tt>k s</tt> such that
--   asynchronous exceptions are deferred until after evaluation has
--   finished.
--   
--   Note that the result type here isn't quite as unrestricted as the
--   polymorphic type might suggest; see the section "RuntimeRep
--   polymorphism in continuation-style primops" for details.
maskUninterruptible# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | Return the maximum of the arguments. When the arguments are
--   numerically equal (e.g. <tt>0.0##</tt> and <tt>-0.0##</tt>) or one of
--   the arguments is not-a-number (NaN), it is unspecified which one is
--   returned.
maxDouble# :: Double# -> Double# -> Double#

-- | Component-wise maximum of two vectors.
maxDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Component-wise maximum of two vectors.
maxDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Component-wise maximum of two vectors.
maxDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Return the maximum of the arguments. When the arguments are
--   numerically equal (e.g. <tt>0.0#</tt> and <tt>-0.0#</tt>) or one of
--   the arguments is not-a-number (NaN), it is unspecified which one is
--   returned.
maxFloat# :: Float# -> Float# -> Float#

-- | Component-wise maximum of two vectors.
maxFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Component-wise maximum of two vectors.
maxFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Component-wise maximum of two vectors.
maxFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Component-wise maximum of two vectors.
maxInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Component-wise maximum of two vectors.
maxInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Component-wise maximum of two vectors.
maxInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Component-wise maximum of two vectors.
maxInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Component-wise maximum of two vectors.
maxInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Component-wise maximum of two vectors.
maxInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Component-wise maximum of two vectors.
maxInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Component-wise maximum of two vectors.
maxInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Component-wise maximum of two vectors.
maxInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Component-wise maximum of two vectors.
maxInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Component-wise maximum of two vectors.
maxInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Component-wise maximum of two vectors.
maxInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Component-wise maximum of two vectors.
maxWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Component-wise maximum of two vectors.
maxWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Component-wise maximum of two vectors.
maxWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Component-wise maximum of two vectors.
maxWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Component-wise maximum of two vectors.
maxWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Component-wise maximum of two vectors.
maxWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Component-wise maximum of two vectors.
maxWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Component-wise maximum of two vectors.
maxWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Component-wise maximum of two vectors.
maxWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Component-wise maximum of two vectors.
maxWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Component-wise maximum of two vectors.
maxWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Component-wise maximum of two vectors.
maxWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Return the minimum of the arguments. When the arguments are
--   numerically equal (e.g. <tt>0.0##</tt> and <tt>-0.0##</tt>) or one of
--   the arguments is not-a-number (NaN), it is unspecified which one is
--   returned.
minDouble# :: Double# -> Double# -> Double#

-- | Component-wise minimum of two vectors.
minDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Component-wise minimum of two vectors.
minDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Component-wise minimum of two vectors.
minDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Return the minimum of the arguments. When the arguments are
--   numerically equal (e.g. <tt>0.0#</tt> and <tt>-0.0#</tt>) or one of
--   the arguments is not-a-number (NaN), it is unspecified which one is
--   returned.
minFloat# :: Float# -> Float# -> Float#

-- | Component-wise minimum of two vectors.
minFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Component-wise minimum of two vectors.
minFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Component-wise minimum of two vectors.
minFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Component-wise minimum of two vectors.
minInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Component-wise minimum of two vectors.
minInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Component-wise minimum of two vectors.
minInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Component-wise minimum of two vectors.
minInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Component-wise minimum of two vectors.
minInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Component-wise minimum of two vectors.
minInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Component-wise minimum of two vectors.
minInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Component-wise minimum of two vectors.
minInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Component-wise minimum of two vectors.
minInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Component-wise minimum of two vectors.
minInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Component-wise minimum of two vectors.
minInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Component-wise minimum of two vectors.
minInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Component-wise minimum of two vectors.
minWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Component-wise minimum of two vectors.
minWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Component-wise minimum of two vectors.
minWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Component-wise minimum of two vectors.
minWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Component-wise minimum of two vectors.
minWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Component-wise minimum of two vectors.
minWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Component-wise minimum of two vectors.
minWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Component-wise minimum of two vectors.
minWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Component-wise minimum of two vectors.
minWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Component-wise minimum of two vectors.
minWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Component-wise minimum of two vectors.
minWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Component-wise minimum of two vectors.
minWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Result is meaningless if two 'Addr#'s are so far apart that their
--   difference doesn't fit in an 'Int#'.
minusAddr# :: Addr# -> Addr# -> Int#

-- | Subtract two vectors element-wise.
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Subtract two vectors element-wise.
minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Subtract two vectors element-wise.
minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
minusFloat# :: Float# -> Float# -> Float#

-- | Subtract two vectors element-wise.
minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Subtract two vectors element-wise.
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Subtract two vectors element-wise.
minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Subtract two vectors element-wise.
minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Subtract two vectors element-wise.
minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Subtract two vectors element-wise.
minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Subtract two vectors element-wise.
minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Subtract two vectors element-wise.
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Subtract two vectors element-wise.
minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Subtract two vectors element-wise.
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Subtract two vectors element-wise.
minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Subtract two vectors element-wise.
minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Subtract two vectors element-wise.
minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Subtract two vectors element-wise.
minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Subtract two vectors element-wise.
minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
minusWord# :: Word# -> Word# -> Word#

-- | Subtract two vectors element-wise.
minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Subtract two vectors element-wise.
minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Subtract two vectors element-wise.
minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Subtract two vectors element-wise.
minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Subtract two vectors element-wise.
minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Subtract two vectors element-wise.
minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Subtract two vectors element-wise.
minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Subtract two vectors element-wise.
minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Subtract two vectors element-wise.
minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Subtract two vectors element-wise.
minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Subtract two vectors element-wise.
minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Subtract two vectors element-wise.
minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Wrap a BCO in a <tt>AP_UPD</tt> thunk which will be updated with the
--   value of the BCO when evaluated.
mkApUpd0# :: BCO -> (# a #)

-- | <tt>'mkWeak#' k v finalizer s</tt> creates a weak reference to value
--   <tt>k</tt>, with an associated reference to some value <tt>v</tt>. If
--   <tt>k</tt> is still alive then <tt>v</tt> can be retrieved using
--   'deRefWeak#'. Note that the type of <tt>k</tt> must be represented by
--   a pointer (i.e. of kind <tt><tt>TYPE</tt> '<tt>LiftedRep</tt> or
--   </tt><tt>TYPE</tt> '<tt>UnliftedRep</tt>@).
mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)

-- | Return non-zero if there is any possibility that the upper word of a
--   signed integer multiply might contain useful information. Return zero
--   only if you are completely sure that no overflow can occur. On a
--   32-bit platform, the recommended implementation is to do a 32 x 32
--   -&gt; 64 signed multiply, and subtract result[63:32] from (result[31]
--   &gt;&gt;signed 31). If this is zero, meaning that the upper word is
--   merely a sign extension of the lower one, no overflow can occur.
--   
--   On a 64-bit platform it is not always possible to acquire the top 64
--   bits of the result. Therefore, a recommended implementation is to take
--   the absolute value of both operands, and return 0 iff bits[63:31] of
--   them are zero, since that means that their magnitudes fit within 31
--   bits, so the magnitude of the product must fit into 62 bits.
--   
--   If in doubt, return non-zero, but do make an effort to create the
--   correct answer for small args, since otherwise the performance of
--   <tt>(*) :: Integer -&gt; Integer -&gt; Integer</tt> will be poor.
mulIntMayOflo# :: Int# -> Int# -> Int#

-- | Intended for use with pinned arrays; otherwise very unsafe!
mutableByteArrayContents# :: MutableByteArray# d -> Addr#
myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
narrow16Int# :: Int# -> Int#
narrow16Word# :: Word# -> Word#
narrow32Int# :: Int# -> Int#
narrow32Word# :: Word# -> Word#
narrow8Int# :: Int# -> Int#
narrow8Word# :: Word# -> Word#
neAddr# :: Addr# -> Addr# -> Int#
neChar# :: Char# -> Char# -> Int#
neFloat# :: Float# -> Float# -> Int#
neInt16# :: Int16# -> Int16# -> Int#
neInt32# :: Int32# -> Int32# -> Int#
neInt64# :: Int64# -> Int64# -> Int#
neInt8# :: Int8# -> Int8# -> Int#
neWord# :: Word# -> Word# -> Int#
neWord16# :: Word16# -> Word16# -> Int#
neWord32# :: Word32# -> Word32# -> Int#
neWord64# :: Word64# -> Word64# -> Int#
neWord8# :: Word8# -> Word8# -> Int#
negateDouble# :: Double# -> Double#

-- | Negate element-wise.
negateDoubleX2# :: DoubleX2# -> DoubleX2#

-- | Negate element-wise.
negateDoubleX4# :: DoubleX4# -> DoubleX4#

-- | Negate element-wise.
negateDoubleX8# :: DoubleX8# -> DoubleX8#
negateFloat# :: Float# -> Float#

-- | Negate element-wise.
negateFloatX16# :: FloatX16# -> FloatX16#

-- | Negate element-wise.
negateFloatX4# :: FloatX4# -> FloatX4#

-- | Negate element-wise.
negateFloatX8# :: FloatX8# -> FloatX8#

-- | Unary negation. Since the negative 'Int#' range extends one further
--   than the positive range, 'negateInt#' of the most negative number is
--   an identity operation. This way, 'negateInt#' is always its own
--   inverse.
negateInt# :: Int# -> Int#
negateInt16# :: Int16# -> Int16#

-- | Negate element-wise.
negateInt16X16# :: Int16X16# -> Int16X16#

-- | Negate element-wise.
negateInt16X32# :: Int16X32# -> Int16X32#

-- | Negate element-wise.
negateInt16X8# :: Int16X8# -> Int16X8#
negateInt32# :: Int32# -> Int32#

-- | Negate element-wise.
negateInt32X16# :: Int32X16# -> Int32X16#

-- | Negate element-wise.
negateInt32X4# :: Int32X4# -> Int32X4#

-- | Negate element-wise.
negateInt32X8# :: Int32X8# -> Int32X8#
negateInt64# :: Int64# -> Int64#

-- | Negate element-wise.
negateInt64X2# :: Int64X2# -> Int64X2#

-- | Negate element-wise.
negateInt64X4# :: Int64X4# -> Int64X4#

-- | Negate element-wise.
negateInt64X8# :: Int64X8# -> Int64X8#
negateInt8# :: Int8# -> Int8#

-- | Negate element-wise.
negateInt8X16# :: Int8X16# -> Int8X16#

-- | Negate element-wise.
negateInt8X32# :: Int8X32# -> Int8X32#

-- | Negate element-wise.
negateInt8X64# :: Int8X64# -> Int8X64#

-- | Like 'newPinnedByteArray#' but allow specifying an arbitrary
--   alignment, which must be a power of two.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
newAlignedPinnedByteArray# :: Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Create a new mutable array with the specified number of elements, in
--   the specified state thread, with each element containing the specified
--   initial value.
newArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)

-- | <tt>'newBCO#' instrs lits ptrs arity bitmap</tt> creates a new
--   bytecode object. The resulting object encodes a function of the given
--   arity with the instructions encoded in <tt>instrs</tt>, and a static
--   reference table usage bitmap given by <tt>bitmap</tt>.
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)

-- | Create a new mutable byte array of specified size (in bytes), in the
--   specified state thread. The size of the memory underlying the array
--   will be rounded up to the platform's word size.
newByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Create new 'MVar#'; initially empty.
newMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). State# d -> (# State# d, MVar# d a #)

-- | Create 'MutVar#' with specified initial value in specified state
--   thread.
newMutVar# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)

-- | Like 'newByteArray#' but GC guarantees not to move it.
newPinnedByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | See <a>GHC.Prim#continuations</a>.
newPromptTag# :: State# RealWorld -> (# State# RealWorld, PromptTag# a #)

-- | Create a new mutable array with the specified number of elements, in
--   the specified state thread, with each element containing the specified
--   initial value.
newSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | Create a new 'TVar#' holding a specified initial value.
newTVar# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
noDuplicate# :: State# d -> State# d
not# :: Word# -> Word#
not64# :: Word64# -> Word64#

-- | Bitwise "not", also known as the binary complement.
notI# :: Int# -> Int#
notWord16# :: Word16# -> Word16#
notWord32# :: Word32# -> Word32#
notWord8# :: Word8# -> Word8#

-- | The null address.
nullAddr# :: Addr#

-- | Returns the number of sparks in the local spark pool.
numSparks# :: State# d -> (# State# d, Int# #)
or# :: Word# -> Word# -> Word#
or64# :: Word64# -> Word64# -> Word64#

-- | Bitwise "or".
orI# :: Int# -> Int# -> Int#
orWord16# :: Word16# -> Word16# -> Word16#
orWord32# :: Word32# -> Word32# -> Word32#
orWord8# :: Word8# -> Word8# -> Word8#
ord# :: Char# -> Int#

-- | Pack the elements of an unboxed tuple into a vector.
packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#

-- | Pack the elements of an unboxed tuple into a vector.
packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#

-- | Pack the elements of an unboxed tuple into a vector.
packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#

-- | Pack the elements of an unboxed tuple into a vector.
packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#

-- | Pack the elements of an unboxed tuple into a vector.
packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#

-- | Pack the elements of an unboxed tuple into a vector.
packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#

-- | Pack the elements of an unboxed tuple into a vector.
packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#

-- | Pack the elements of an unboxed tuple into a vector.
packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#

-- | Pack the elements of an unboxed tuple into a vector.
packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#

-- | Pack the elements of an unboxed tuple into a vector.
packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#

-- | Pack the elements of an unboxed tuple into a vector.
packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#

-- | Pack the elements of an unboxed tuple into a vector.
packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#

-- | Pack the elements of an unboxed tuple into a vector.
packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#

-- | Pack the elements of an unboxed tuple into a vector.
packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#

-- | Pack the elements of an unboxed tuple into a vector.
packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#

-- | Pack the elements of an unboxed tuple into a vector.
packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#

-- | Pack the elements of an unboxed tuple into a vector.
packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#

-- | Pack the elements of an unboxed tuple into a vector.
packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#

-- | Pack the elements of an unboxed tuple into a vector.
packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#

-- | Pack the elements of an unboxed tuple into a vector.
packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#

-- | Pack the elements of an unboxed tuple into a vector.
packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#

-- | Pack the elements of an unboxed tuple into a vector.
packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#

-- | Pack the elements of an unboxed tuple into a vector.
packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#

-- | Pack the elements of an unboxed tuple into a vector.
packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#

-- | Pack the elements of an unboxed tuple into a vector.
packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#

-- | Pack the elements of an unboxed tuple into a vector.
packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#

-- | Pack the elements of an unboxed tuple into a vector.
packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#

-- | Pack the elements of an unboxed tuple into a vector.
packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#

-- | Pack the elements of an unboxed tuple into a vector.
packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#

-- | Pack the elements of an unboxed tuple into a vector.
packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#

-- | Create a new spark evaluating the given argument. The return value
--   should always be 1. Users are encouraged to use spark# instead.
par# :: a -> Int#

-- | Deposit bits to a word at locations specified by a mask, aka
--   <a>parallel bit deposit</a>.
--   
--   Software emulation:
--   
--   <pre>
--   pdep :: Word -&gt; Word -&gt; Word
--   pdep src mask = go 0 src mask
--     where
--       go :: Word -&gt; Word -&gt; Word -&gt; Word
--       go result _ 0 = result
--       go result src mask = go newResult newSrc newMask
--         where
--           maskCtz   = countTrailingZeros mask
--           newResult = if testBit src 0 then setBit result maskCtz else result
--           newSrc    = src `shiftR` 1
--           newMask   = clearBit mask maskCtz
--   </pre>
pdep# :: Word# -> Word# -> Word#

-- | Deposit bits to lower 16 bits of a word at locations specified by a
--   mask.
pdep16# :: Word# -> Word# -> Word#

-- | Deposit bits to lower 32 bits of a word at locations specified by a
--   mask.
pdep32# :: Word# -> Word# -> Word#

-- | Deposit bits to a word at locations specified by a mask.
pdep64# :: Word64# -> Word64# -> Word64#

-- | Deposit bits to lower 8 bits of a word at locations specified by a
--   mask.
pdep8# :: Word# -> Word# -> Word#

-- | Extract bits from a word at locations specified by a mask, aka
--   <a>parallel bit extract</a>.
--   
--   Software emulation:
--   
--   <pre>
--   pext :: Word -&gt; Word -&gt; Word
--   pext src mask = loop 0 0 0
--     where
--       loop i count result
--         | i &gt;= finiteBitSize (0 :: Word)
--         = result
--         | testBit mask i
--         = loop (i + 1) (count + 1) (if testBit src i then setBit result count else result)
--         | otherwise
--         = loop (i + 1) count result
--   </pre>
pext# :: Word# -> Word# -> Word#

-- | Extract bits from lower 16 bits of a word at locations specified by a
--   mask.
pext16# :: Word# -> Word# -> Word#

-- | Extract bits from lower 32 bits of a word at locations specified by a
--   mask.
pext32# :: Word# -> Word# -> Word#

-- | Extract bits from a word at locations specified by a mask.
pext64# :: Word64# -> Word64# -> Word64#

-- | Extract bits from lower 8 bits of a word at locations specified by a
--   mask.
pext8# :: Word# -> Word# -> Word#
plusAddr# :: Addr# -> Int# -> Addr#

-- | Add two vectors element-wise.
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Add two vectors element-wise.
plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Add two vectors element-wise.
plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
plusFloat# :: Float# -> Float# -> Float#

-- | Add two vectors element-wise.
plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Add two vectors element-wise.
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Add two vectors element-wise.
plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
plusInt16# :: Int16# -> Int16# -> Int16#

-- | Add two vectors element-wise.
plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Add two vectors element-wise.
plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Add two vectors element-wise.
plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
plusInt32# :: Int32# -> Int32# -> Int32#

-- | Add two vectors element-wise.
plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Add two vectors element-wise.
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Add two vectors element-wise.
plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
plusInt64# :: Int64# -> Int64# -> Int64#

-- | Add two vectors element-wise.
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Add two vectors element-wise.
plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Add two vectors element-wise.
plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
plusInt8# :: Int8# -> Int8# -> Int8#

-- | Add two vectors element-wise.
plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Add two vectors element-wise.
plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Add two vectors element-wise.
plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
plusWord# :: Word# -> Word# -> Word#
plusWord16# :: Word16# -> Word16# -> Word16#

-- | Add two vectors element-wise.
plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Add two vectors element-wise.
plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Add two vectors element-wise.
plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Add unsigned integers, with the high part (carry) in the first
--   component of the returned pair and the low part in the second
--   component of the pair. See also 'addWordC#'.
plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
plusWord32# :: Word32# -> Word32# -> Word32#

-- | Add two vectors element-wise.
plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Add two vectors element-wise.
plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Add two vectors element-wise.
plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
plusWord64# :: Word64# -> Word64# -> Word64#

-- | Add two vectors element-wise.
plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Add two vectors element-wise.
plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Add two vectors element-wise.
plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
plusWord8# :: Word8# -> Word8# -> Word8#

-- | Add two vectors element-wise.
plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Add two vectors element-wise.
plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Add two vectors element-wise.
plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Count the number of set bits in a word.
popCnt# :: Word# -> Word#

-- | Count the number of set bits in the lower 16 bits of a word.
popCnt16# :: Word# -> Word#

-- | Count the number of set bits in the lower 32 bits of a word.
popCnt32# :: Word# -> Word#

-- | Count the number of set bits in a 64-bit word.
popCnt64# :: Word64# -> Word#

-- | Count the number of set bits in the lower 8 bits of a word.
popCnt8# :: Word# -> Word#
powerFloat# :: Float# -> Float# -> Float#
prefetchAddr0# :: Addr# -> Int# -> State# d -> State# d
prefetchAddr1# :: Addr# -> Int# -> State# d -> State# d
prefetchAddr2# :: Addr# -> Int# -> State# d -> State# d
prefetchAddr3# :: Addr# -> Int# -> State# d -> State# d
prefetchByteArray0# :: ByteArray# -> Int# -> State# d -> State# d
prefetchByteArray1# :: ByteArray# -> Int# -> State# d -> State# d
prefetchByteArray2# :: ByteArray# -> Int# -> State# d -> State# d
prefetchByteArray3# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray0# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchMutableByteArray1# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchMutableByteArray2# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchMutableByteArray3# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchValue0# :: a -> State# d -> State# d
prefetchValue1# :: a -> State# d -> State# d
prefetchValue2# :: a -> State# d -> State# d
prefetchValue3# :: a -> State# d -> State# d

-- | See <a>GHC.Prim#continuations</a>.
prompt# :: PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | Witness for an unboxed 'Proxy#' value, which has no runtime
--   representation.
proxy# :: forall {k} (a :: k). Proxy# a

-- | If 'MVar#' is full, block until it becomes empty. Then store value arg
--   as its new contents.
putMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> a -> State# d -> State# d

-- | Rounds towards zero. The behavior is undefined if the second argument
--   is zero.
quotInt# :: Int# -> Int# -> Int#
quotInt16# :: Int16# -> Int16# -> Int16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
quotInt32# :: Int32# -> Int32# -> Int32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
quotInt64# :: Int64# -> Int64# -> Int64#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
quotInt8# :: Int8# -> Int8# -> Int8#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Rounds towards zero.
quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)

-- | Takes high word of dividend, then low word of dividend, then divisor.
--   Requires that high word &lt; divisor.
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
quotWord# :: Word# -> Word# -> Word#
quotWord16# :: Word16# -> Word16# -> Word16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
quotWord32# :: Word32# -> Word32# -> Word32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
quotWord64# :: Word64# -> Word64# -> Word64#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
quotWord8# :: Word8# -> Word8# -> Word8#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Rounds towards zero element-wise.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) (b :: TYPE r). a -> b
raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b

-- | Read a machine address from mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readAddrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)

-- | Read a machine address from mutable address; offset in machine words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readAddrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)

-- | Read from specified index of mutable array. Result is not yet
--   evaluated.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)

-- | Read an 8-bit character from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read an 8-bit character from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a double-precision floating-point value from mutable array;
--   offset in 8-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Read a double-precision floating-point value from mutable address;
--   offset in 8-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Read a single-precision floating-point value from mutable array;
--   offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Read a single-precision floating-point value from mutable address;
--   offset in 4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Read a 16-bit signed integer from mutable array; offset in 2-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Read a 16-bit signed integer from mutable address; offset in 2-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Read a 32-bit signed integer from mutable array; offset in 4-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Read a 32-bit signed integer from mutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Read a 64-bit signed integer from mutable array; offset in 8-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Read a 64-bit signed integer from mutable address; offset in 8-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Read an 8-bit signed integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Read an 8-bit signed integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Read a word-sized integer from mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | Read a word-sized integer from mutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readIntOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | If 'MVar#' is empty, block until it becomes full. Then read its
--   contents without modifying the MVar, without possibility of
--   intervention from other threads.
readMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)

-- | Read contents of 'MutVar#'. Result is not yet evaluated.
readMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)

-- | Read from specified index of mutable array. Result is not yet
--   evaluated.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)

-- | Read a 'StablePtr#' value from mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readStablePtrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | Read a 'StablePtr#' value from mutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readStablePtrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | Read contents of 'TVar#' inside an STM transaction, i.e. within a call
--   to 'atomically#'. Does not force evaluation of the result.
readTVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)

-- | Read contents of 'TVar#' outside an STM transaction. Does not force
--   evaluation of the result.
readTVarIO# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)

-- | Read a 32-bit character from mutable array; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWideCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a 32-bit character from mutable address; offset in 4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWideCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a 16-bit unsigned integer from mutable array; offset in 2-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Read a 16-bit unsigned integer from mutable address; offset in 2-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Read a 32-bit unsigned integer from mutable array; offset in 4-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Read a 32-bit unsigned integer from mutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Read a 64-bit unsigned integer from mutable array; offset in 8-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Read a 64-bit unsigned integer from mutable address; offset in 8-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Read an 8-bit unsigned integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)

-- | Read a machine address from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)

-- | Read an 8-bit character from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a double-precision floating-point value from mutable array;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)

-- | Read a single-precision floating-point value from mutable array;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)

-- | Read a word-sized integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | Read a 16-bit signed integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)

-- | Read a 32-bit signed integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)

-- | Read a 64-bit signed integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)

-- | Read a 'StablePtr#' value from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | Read a 32-bit character from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a word-sized unsigned integer from mutable array; offset in
--   bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | Read a 16-bit unsigned integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)

-- | Read a 32-bit unsigned integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)

-- | Read a 64-bit unsigned integer from mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Read an 8-bit unsigned integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8# #)

-- | Read a machine address from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)

-- | Read an 8-bit character from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsChar# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a double-precision floating-point value from mutable address;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)

-- | Read a single-precision floating-point value from mutable address;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)

-- | Read a word-sized integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsInt# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | Read a 16-bit signed integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# d -> (# State# d, Int16# #)

-- | Read a 32-bit signed integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# d -> (# State# d, Int32# #)

-- | Read a 64-bit signed integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# d -> (# State# d, Int64# #)

-- | Read a 'StablePtr#' value from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | Read a 32-bit character from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWideChar# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | Read a word-sized unsigned integer from mutable address; offset in
--   bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | Read a 16-bit unsigned integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# d -> (# State# d, Word16# #)

-- | Read a 32-bit unsigned integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# d -> (# State# d, Word32# #)

-- | Read a 64-bit unsigned integer from mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# d -> (# State# d, Word64# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Read a vector from the specified index of a mutable array. The index
--   is counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Reads vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Read a word-sized unsigned integer from mutable array; offset in
--   machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWordArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | Read a word-sized unsigned integer from mutable address; offset in
--   machine words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWordOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | The token used in the implementation of the IO monad as a state monad.
--   It does not pass any information at runtime. See also
--   'GHC.Magic.runRW#'.
realWorld# :: State# RealWorld

-- | Returns <tt>1#</tt> if the given pointers are equal and <tt>0#</tt>
--   otherwise.
reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)). a -> b -> Int#

-- | Return the remainder when the 'Addr#' arg, treated like an 'Int#', is
--   divided by the 'Int#' arg.
remAddr# :: Addr# -> Int# -> Int#

-- | Satisfies <tt>('quotInt#' x y) <tt>*#</tt> y <tt>+#</tt> ('remInt#' x
--   y) == x</tt>. The behavior is undefined if the second argument is
--   zero.
remInt# :: Int# -> Int# -> Int#
remInt16# :: Int16# -> Int16# -> Int16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
remInt32# :: Int32# -> Int32# -> Int32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
remInt64# :: Int64# -> Int64# -> Int64#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
remInt8# :: Int8# -> Int8# -> Int8#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
remWord# :: Word# -> Word# -> Word#
remWord16# :: Word16# -> Word16# -> Word16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
remWord32# :: Word32# -> Word32# -> Word32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
remWord64# :: Word64# -> Word64# -> Word64#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
remWord8# :: Word8# -> Word8# -> Word8#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Satisfies <tt>('quot#' x y) 'times#' y 'plus#' ('rem#' x y) == x</tt>.
--   
--   Note: Most CPU ISAs do not contain any SIMD integer division
--   instructions. Do not expect high performance.
remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Resize mutable byte array to new specified size (in bytes), shrinking
--   or growing it. The returned 'MutableByteArray#' is either the original
--   'MutableByteArray#' resized in-place or, if not possible, a newly
--   allocated (unpinned) 'MutableByteArray#' (with the original content
--   copied over).
--   
--   To avoid undefined behaviour, the original 'MutableByteArray#' shall
--   not be accessed anymore after a 'resizeMutableByteArray#' has been
--   performed. Moreover, no reference to the old one should be kept in
--   order to allow garbage collection of the original 'MutableByteArray#'
--   in case a new 'MutableByteArray#' had to be allocated.
resizeMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
retry# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} {n :: Multiplicity} {o :: Multiplicity} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a %n -> b %o -> c) -> b %o -> a %n -> c

-- | The value of <tt><tt>seq</tt> a b</tt> is bottom if <tt>a</tt> is
--   bottom, and otherwise equal to <tt>b</tt>. In other words, it
--   evaluates the first argument <tt>a</tt> to weak head normal form
--   (WHNF). <tt>seq</tt> is usually introduced to improve performance by
--   avoiding unneeded laziness.
--   
--   A note on evaluation order: the expression <tt><tt>seq</tt> a b</tt>
--   does <i>not</i> guarantee that <tt>a</tt> will be evaluated before
--   <tt>b</tt>. The only guarantee given by <tt>seq</tt> is that the both
--   <tt>a</tt> and <tt>b</tt> will be evaluated before <tt>seq</tt>
--   returns a value. In particular, this means that <tt>b</tt> may be
--   evaluated before <tt>a</tt>. If you need to guarantee a specific order
--   of evaluation, you must use the function <tt>pseq</tt> from the
--   "parallel" package.
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
infixr 0 `seq`

-- | <tt>'setAddrRange#' dest len c</tt> sets all of the bytes in
--   <tt>[dest, dest+len)</tt> to the value <tt>c</tt>.
--   
--   Analogous to the standard C function <tt>memset</tt>, but with a
--   different argument order.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld

-- | <tt>'setByteArray#' ba off len c</tt> sets the byte range <tt>[off,
--   off+len)</tt> of the 'MutableByteArray#' to the byte <tt>c</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d

-- | Sets the allocation counter for the another thread to the given value.
--   This doesn't take allocations into the current nursery chunk into
--   account. Therefore it is only accurate if the other thread is not
--   currently running.
setOtherThreadAllocationCounter# :: Int64# -> ThreadId# -> State# RealWorld -> State# RealWorld

-- | Sets the allocation counter for the current thread to the given value.
setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld

-- | Shrink mutable byte array to new specified size (in bytes), in the
--   specified state thread. The new size argument must be less than or
--   equal to the current size as reported by 'getSizeofMutableByteArray#'.
--   
--   Assuming the non-profiling RTS, this primitive compiles to an O(1)
--   operation in C--, modifying the array in-place. Backends bypassing C--
--   representation (such as JavaScript) might behave differently.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
shrinkMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> State# d

-- | Shrink mutable array to new specified size, in the specified state
--   thread. The new size argument must be less than or equal to the
--   current size as reported by 'getSizeofSmallMutableArray#'.
--   
--   Assuming the non-profiling RTS, for the copying garbage collector
--   (default) this primitive compiles to an O(1) operation in C--,
--   modifying the array in-place. For the non-moving garbage collector,
--   however, the time is proportional to the number of elements shrinked
--   out. Backends bypassing C-- representation (such as JavaScript) might
--   behave differently.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
shrinkSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> State# d

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleDoubleX2# :: DoubleX2# -> DoubleX2# -> (# Int#, Int# #) -> DoubleX2#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleDoubleX4# :: DoubleX4# -> DoubleX4# -> (# Int#, Int#, Int#, Int# #) -> DoubleX4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleDoubleX8# :: DoubleX8# -> DoubleX8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> DoubleX8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleFloatX16# :: FloatX16# -> FloatX16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> FloatX16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleFloatX4# :: FloatX4# -> FloatX4# -> (# Int#, Int#, Int#, Int# #) -> FloatX4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleFloatX8# :: FloatX8# -> FloatX8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> FloatX8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt16X16# :: Int16X16# -> Int16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt16X32# :: Int16X32# -> Int16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X32#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt16X8# :: Int16X8# -> Int16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt32X16# :: Int32X16# -> Int32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt32X4# :: Int32X4# -> Int32X4# -> (# Int#, Int#, Int#, Int# #) -> Int32X4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt32X8# :: Int32X8# -> Int32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt64X2# :: Int64X2# -> Int64X2# -> (# Int#, Int# #) -> Int64X2#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt64X4# :: Int64X4# -> Int64X4# -> (# Int#, Int#, Int#, Int# #) -> Int64X4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt64X8# :: Int64X8# -> Int64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int64X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt8X16# :: Int8X16# -> Int8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt8X32# :: Int8X32# -> Int8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X32#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleInt8X64# :: Int8X64# -> Int8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X64#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord16X16# :: Word16X16# -> Word16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord16X32# :: Word16X32# -> Word16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X32#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord16X8# :: Word16X8# -> Word16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord32X16# :: Word32X16# -> Word32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word32X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord32X4# :: Word32X4# -> Word32X4# -> (# Int#, Int#, Int#, Int# #) -> Word32X4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord32X8# :: Word32X8# -> Word32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word32X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord64X2# :: Word64X2# -> Word64X2# -> (# Int#, Int# #) -> Word64X2#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord64X4# :: Word64X4# -> Word64X4# -> (# Int#, Int#, Int#, Int# #) -> Word64X4#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord64X8# :: Word64X8# -> Word64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word64X8#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord8X16# :: Word8X16# -> Word8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X16#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord8X32# :: Word8X32# -> Word8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X32#

-- | Shuffle elements of the concatenation of the input two vectors into
--   the result vector. The indices must be compile-time constants.
shuffleWord8X64# :: Word8X64# -> Word8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X64#
sinDouble# :: Double# -> Double#
sinFloat# :: Float# -> Float#
sinhDouble# :: Double# -> Double#
sinhFloat# :: Float# -> Float#

-- | Return the number of elements in the array.
sizeofArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int#

-- | Return the size of the array in bytes.
sizeofByteArray# :: ByteArray# -> Int#

-- | Return the number of elements in the array.
sizeofMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int#

-- | Return the size of the array in bytes. <b>Deprecated</b>, it is unsafe
--   in the presence of 'shrinkMutableByteArray#' and
--   'resizeMutableByteArray#' operations on the same mutable byte array.

-- | <i>Deprecated: Use 'getSizeofMutableByteArray#' instead </i>
sizeofMutableByteArray# :: MutableByteArray# d -> Int#

-- | Return the number of elements in the array.
sizeofSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int#

-- | Return the number of elements in the array. <b>Deprecated</b>, it is
--   unsafe in the presence of 'shrinkSmallMutableArray#' and
--   <tt>resizeSmallMutableArray#</tt> operations on the same small mutable
--   array.

-- | <i>Deprecated: Use 'getSizeofSmallMutableArray#' instead </i>
sizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int#
spark# :: a -> State# d -> (# State# d, a #)
sqrtDouble# :: Double# -> Double#
sqrtFloat# :: Float# -> Float#
stableNameToInt# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StableName# a -> Int#
subInt16# :: Int16# -> Int16# -> Int16#
subInt32# :: Int32# -> Int32# -> Int32#
subInt64# :: Int64# -> Int64# -> Int64#
subInt8# :: Int8# -> Int8# -> Int8#

-- | Subtract signed integers reporting overflow. First member of result is
--   the difference truncated to an 'Int#'; second member is zero if the
--   true difference fits in an 'Int#', nonzero if overflow occurred (the
--   difference is either too large or too small to fit in an 'Int#').
subIntC# :: Int# -> Int# -> (# Int#, Int# #)
subWord16# :: Word16# -> Word16# -> Word16#
subWord32# :: Word32# -> Word32# -> Word32#
subWord64# :: Word64# -> Word64# -> Word64#
subWord8# :: Word8# -> Word8# -> Word8#

-- | Subtract unsigned integers reporting overflow. The first element of
--   the pair is the result. The second element is the carry flag, which is
--   nonzero on overflow.
subWordC# :: Word# -> Word# -> (# Word#, Int# #)
tagToEnum# :: Int# -> a

-- | If 'MVar#' is empty, block until it becomes full. Then remove and
--   return its contents, and set it empty.
takeMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
tanDouble# :: Double# -> Double#
tanFloat# :: Float# -> Float#
tanhDouble# :: Double# -> Double#
tanhFloat# :: Float# -> Float#

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
thawArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
thawSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | Get the label of the given thread. Morally of type <tt>ThreadId# -&gt;
--   IO (Maybe ByteArray#)</tt>, with a <tt>1#</tt> tag denoting
--   <tt>Just</tt>.
threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #)

-- | Get the status of the given thread. Result is <tt>(ThreadStatus,
--   Capability, Locked)</tt> where <tt>ThreadStatus</tt> is one of the
--   status constants defined in <tt>rts/Constants.h</tt>,
--   <tt>Capability</tt> is the number of the capability which currently
--   owns the thread, and <tt>Locked</tt> is a boolean indicating whether
--   the thread is bound to that capability.
threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)

-- | Multiply two vectors element-wise.
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Multiply two vectors element-wise.
timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Multiply two vectors element-wise.
timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
timesFloat# :: Float# -> Float# -> Float#

-- | Multiply two vectors element-wise.
timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Multiply two vectors element-wise.
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Multiply two vectors element-wise.
timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
timesInt16# :: Int16# -> Int16# -> Int16#

-- | Multiply two vectors element-wise.
timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Multiply two vectors element-wise.
timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Multiply two vectors element-wise.
timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Return a triple (isHighNeeded,high,low) where high and low are
--   respectively the high and low bits of the double-word result.
--   isHighNeeded is a cheap way to test if the high word is a
--   sign-extension of the low word (isHighNeeded = 0#) or not
--   (isHighNeeded = 1#).
timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
timesInt32# :: Int32# -> Int32# -> Int32#

-- | Multiply two vectors element-wise.
timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Multiply two vectors element-wise.
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Multiply two vectors element-wise.
timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
timesInt64# :: Int64# -> Int64# -> Int64#

-- | Multiply two vectors element-wise.
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Multiply two vectors element-wise.
timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Multiply two vectors element-wise.
timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
timesInt8# :: Int8# -> Int8# -> Int8#

-- | Multiply two vectors element-wise.
timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Multiply two vectors element-wise.
timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Multiply two vectors element-wise.
timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
timesWord# :: Word# -> Word# -> Word#
timesWord16# :: Word16# -> Word16# -> Word16#

-- | Multiply two vectors element-wise.
timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Multiply two vectors element-wise.
timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Multiply two vectors element-wise.
timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
timesWord32# :: Word32# -> Word32# -> Word32#

-- | Multiply two vectors element-wise.
timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Multiply two vectors element-wise.
timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Multiply two vectors element-wise.
timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
timesWord64# :: Word64# -> Word64# -> Word64#

-- | Multiply two vectors element-wise.
timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Multiply two vectors element-wise.
timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Multiply two vectors element-wise.
timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
timesWord8# :: Word8# -> Word8# -> Word8#

-- | Multiply two vectors element-wise.
timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Multiply two vectors element-wise.
timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Multiply two vectors element-wise.
timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
touch# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> State# d

-- | Emits an event via the RTS tracing framework. The contents of the
--   event is the binary object passed as the first argument with the given
--   length passed as the second argument. The event will be emitted to the
--   <tt>.eventlog</tt> file.
traceBinaryEvent# :: Addr# -> Int# -> State# d -> State# d

-- | Emits an event via the RTS tracing framework. The contents of the
--   event is the zero-terminated byte string passed as the first argument.
--   The event will be emitted either to the <tt>.eventlog</tt> file, or to
--   stderr, depending on the runtime RTS flags.
traceEvent# :: Addr# -> State# d -> State# d

-- | Emits a marker event via the RTS tracing framework. The contents of
--   the event is the zero-terminated byte string passed as the first
--   argument. The event will be emitted either to the <tt>.eventlog</tt>
--   file, or to stderr, depending on the runtime RTS flags.
traceMarker# :: Addr# -> State# d -> State# d

-- | If 'MVar#' is full, immediately return with integer 0. Otherwise,
--   store value arg as 'MVar#''s new contents, and return with integer 1.
tryPutMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> a -> State# d -> (# State# d, Int# #)

-- | If 'MVar#' is empty, immediately return with integer 0 and value
--   undefined. Otherwise, return with integer 1 and contents of 'MVar#'.
tryReadMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)

-- | If 'MVar#' is empty, immediately return with integer 0 and value
--   undefined. Otherwise, return with integer 1 and contents of 'MVar#',
--   and set 'MVar#' empty.
tryTakeMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)

-- | Shift left. Result undefined if shift amount is not in the range 0 to
--   word size - 1 inclusive.
uncheckedIShiftL# :: Int# -> Int# -> Int#
uncheckedIShiftL64# :: Int64# -> Int# -> Int64#

-- | Shift right arithmetic. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#

-- | Shift right logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedIShiftRL# :: Int# -> Int# -> Int#
uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#

-- | Shift left logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedShiftL# :: Word# -> Int# -> Word#
uncheckedShiftL64# :: Word64# -> Int# -> Word64#
uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#

-- | Shift right logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedShiftRL# :: Word# -> Int# -> Word#
uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#

-- | <tt>'unmaskAsyncUninterruptible#' k s</tt> evaluates <tt>k s</tt> such
--   that asynchronous exceptions are unmasked.
--   
--   Note that the result type here isn't quite as unrestricted as the
--   polymorphic type might suggest; see the section "RuntimeRep
--   polymorphism in continuation-style primops" for details.
unmaskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | <tt>'unpackClosure#' closure</tt> copies the closure and pointers in
--   the payload of the given closure into two new arrays, and returns a
--   pointer to the first word of the closure's info table, a non-pointer
--   array for the raw bytes of the closure, and a pointer array for the
--   pointers in the payload.
unpackClosure# :: a -> (# Addr#, ByteArray#, Array# b #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt16X16# :: Int16X16# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt16X32# :: Int16X32# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt16X8# :: Int16X8# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt32X16# :: Int32X16# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt32X4# :: Int32X4# -> (# Int32#, Int32#, Int32#, Int32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt32X8# :: Int32X8# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt64X2# :: Int64X2# -> (# Int64#, Int64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt64X4# :: Int64X4# -> (# Int64#, Int64#, Int64#, Int64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt64X8# :: Int64X8# -> (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt8X16# :: Int8X16# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt8X32# :: Int8X32# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackInt8X64# :: Int8X64# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord16X16# :: Word16X16# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord16X32# :: Word16X32# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord16X8# :: Word16X8# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord32X16# :: Word32X16# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord32X4# :: Word32X4# -> (# Word32#, Word32#, Word32#, Word32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord32X8# :: Word32X8# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord64X2# :: Word64X2# -> (# Word64#, Word64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord64X4# :: Word64X4# -> (# Word64#, Word64#, Word64#, Word64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord64X8# :: Word64X8# -> (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord8X16# :: Word8X16# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord8X32# :: Word8X32# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)

-- | Unpack the elements of a vector into an unboxed tuple.
unpackWord8X64# :: Word8X64# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)

-- | Make a mutable array immutable, without copying.
unsafeFreezeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> State# d -> (# State# d, Array# a #)

-- | Make a mutable byte array immutable, without copying.
unsafeFreezeByteArray# :: MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)

-- | Make a mutable array immutable, without copying.
unsafeFreezeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)

-- | Make an immutable array mutable, without copying.
unsafeThawArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> State# d -> (# State# d, MutableArray# d a #)

-- | Make an immutable byte array mutable, without copying.
unsafeThawByteArray# :: ByteArray# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Make an immutable array mutable, without copying.
unsafeThawSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | This is an alias for the unboxed unit tuple constructor. In earlier
--   versions of GHC, 'void#' was a value of the primitive type 'Void#',
--   which is now defined to be <tt>(# #)</tt>.

-- | <i>Deprecated: Use an unboxed unit tuple instead </i>
void# :: (# #)

-- | Block until input is available on specified file descriptor.
waitRead# :: Int# -> State# d -> State# d

-- | Block until output is possible on specified file descriptor.
waitWrite# :: Int# -> State# d -> State# d
word16ToInt16# :: Word16# -> Int16#
word16ToWord# :: Word16# -> Word#

-- | Convert an 'Word#' to the corresponding 'Double#' with the same
--   integral value (up to truncation due to floating-point precision).
--   e.g. <tt>'word2Double#' 1## == 1.0##</tt>
word2Double# :: Word# -> Double#

-- | Convert an 'Word#' to the corresponding 'Float#' with the same
--   integral value (up to truncation due to floating-point precision).
--   e.g. <tt>'word2Float#' 1## == 1.0#</tt>
word2Float# :: Word# -> Float#
word2Int# :: Word# -> Int#
word32ToInt32# :: Word32# -> Int32#
word32ToWord# :: Word32# -> Word#
word64ToInt64# :: Word64# -> Int64#
word64ToWord# :: Word64# -> Word#
word8ToInt8# :: Word8# -> Int8#
word8ToWord# :: Word8# -> Word#
wordToWord16# :: Word# -> Word16#
wordToWord32# :: Word# -> Word32#
wordToWord64# :: Word# -> Word64#
wordToWord8# :: Word# -> Word8#

-- | Write a machine address to mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeAddrArray# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d

-- | Write a machine address to mutable address; offset in machine words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d

-- | Write to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> a -> State# d -> State# d

-- | Write an 8-bit character to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Write an 8-bit character to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | Write a double-precision floating-point value to mutable array; offset
--   in 8-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleArray# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d

-- | Write a double-precision floating-point value to mutable address;
--   offset in 8-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX2Array# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX4Array# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX8Array# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d

-- | Write a single-precision floating-point value to mutable array; offset
--   in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatArray# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d

-- | Write a single-precision floating-point value to mutable address;
--   offset in 4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX16Array# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX4Array# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX8Array# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d

-- | Write a 16-bit signed integer to mutable array; offset in 2-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16Array# :: MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d

-- | Write a 16-bit signed integer to mutable address; offset in 2-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X16Array# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X32Array# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X8Array# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d

-- | Write a 32-bit signed integer to mutable array; offset in 4-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32Array# :: MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d

-- | Write a 32-bit signed integer to mutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X16Array# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X4Array# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X8Array# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d

-- | Write a 64-bit signed integer to mutable array; offset in 8-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64Array# :: MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d

-- | Write a 64-bit signed integer to mutable address; offset in 8-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X2Array# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X4Array# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X8Array# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d

-- | Write an 8-bit signed integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8Array# :: MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d

-- | Write an 8-bit signed integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X16Array# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X32Array# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X64Array# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d

-- | Write a word-sized integer to mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Write a word-sized integer to mutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | Write contents of 'MutVar#'.
writeMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> State# d -> State# d

-- | Write to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> State# d -> State# d

-- | Write a 'StablePtr#' value to mutable array; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeStablePtrArray# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d

-- | Write a 'StablePtr#' value to mutable address; offset in machine
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d

-- | Write contents of 'TVar#'.
writeTVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> a -> State# d -> State# d

-- | Write a 32-bit character to mutable array; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWideCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Write a 32-bit character to mutable address; offset in 4-byte words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | Write a 16-bit unsigned integer to mutable array; offset in 2-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16Array# :: MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d

-- | Write a 16-bit unsigned integer to mutable address; offset in 2-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X16Array# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X32Array# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X8Array# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d

-- | Write a 32-bit unsigned integer to mutable array; offset in 4-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32Array# :: MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d

-- | Write a 32-bit unsigned integer to mutable address; offset in 4-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X16Array# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X4Array# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X8Array# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d

-- | Write a 64-bit unsigned integer to mutable array; offset in 8-byte
--   words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64Array# :: MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d

-- | Write a 64-bit unsigned integer to mutable address; offset in 8-byte
--   words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X2Array# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X4Array# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X8Array# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d

-- | Write an 8-bit unsigned integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8Array# :: MutableByteArray# d -> Int# -> Word8# -> State# d -> State# d

-- | Write a machine address to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d

-- | Write an 8-bit character to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Write a double-precision floating-point value to mutable array; offset
--   in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d

-- | Write a single-precision floating-point value to mutable array; offset
--   in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d

-- | Write a word-sized integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Write a 16-bit signed integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d

-- | Write a 32-bit signed integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d

-- | Write a 64-bit signed integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d

-- | Write a 'StablePtr#' value to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d

-- | Write a 32-bit character to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Write a word-sized unsigned integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Write a 16-bit unsigned integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d

-- | Write a 32-bit unsigned integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d

-- | Write a 64-bit unsigned integer to mutable array; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d

-- | Write an 8-bit unsigned integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# d -> State# d

-- | Write a machine address to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d

-- | Write an 8-bit character to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | Write a double-precision floating-point value to mutable address;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# d -> State# d

-- | Write a single-precision floating-point value to mutable address;
--   offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# d -> State# d

-- | Write a word-sized integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | Write a 16-bit signed integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# d -> State# d

-- | Write a 32-bit signed integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# d -> State# d

-- | Write a 64-bit signed integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# d -> State# d

-- | Write a 'StablePtr#' value to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d

-- | Write a 32-bit character to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | Write a word-sized unsigned integer to mutable address; offset in
--   bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | Write a 16-bit unsigned integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# d -> State# d

-- | Write a 32-bit unsigned integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# d -> State# d

-- | Write a 64-bit unsigned integer to mutable address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X16Array# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X32Array# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d

-- | Write a vector to the specified index of a mutable array. The index is
--   counted in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X64Array# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d

-- | Write vector; offset in units of SIMD vectors (not scalar elements).
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d

-- | Write a word-sized unsigned integer to mutable array; offset in
--   machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWordArray# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Write a word-sized unsigned integer to mutable address; offset in
--   machine words.
--   
--   On some platforms, the access may fail for an insufficiently aligned
--   <tt>Addr#</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
xor# :: Word# -> Word# -> Word#
xor64# :: Word64# -> Word64# -> Word64#

-- | Bitwise "xor".
xorI# :: Int# -> Int# -> Int#
xorWord16# :: Word16# -> Word16# -> Word16#
xorWord32# :: Word32# -> Word32# -> Word32#
xorWord8# :: Word8# -> Word8# -> Word8#
yield# :: State# RealWorld -> State# RealWorld
newtype ArrayArray# :: UnliftedType
ArrayArray# :: Array# ByteArray# -> ArrayArray#
newtype MutableArrayArray# s :: UnliftedType
MutableArrayArray# :: MutableArray# s ByteArray# -> MutableArrayArray# s

-- | The <a>Down</a> type allows you to reverse sort order conveniently. A
--   value of type <tt><a>Down</a> a</tt> contains a value of type
--   <tt>a</tt> (represented as <tt><a>Down</a> a</tt>).
--   
--   If <tt>a</tt> has an <tt><a>Ord</a></tt> instance associated with it
--   then comparing two values thus wrapped will give you the opposite of
--   their normal sort order. This is particularly useful when sorting in
--   generalised list comprehensions, as in: <tt>then sortWith by
--   <a>Down</a> x</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; compare True False
--   GT
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; compare (Down True) (Down False)
--   LT
--   </pre>
--   
--   If <tt>a</tt> has a <tt><a>Bounded</a></tt> instance then the wrapped
--   instance also respects the reversed ordering by exchanging the values
--   of <tt><a>minBound</a></tt> and <tt><a>maxBound</a></tt>.
--   
--   <pre>
--   &gt;&gt;&gt; minBound :: Int
--   -9223372036854775808
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; minBound :: Down Int
--   Down 9223372036854775807
--   </pre>
--   
--   All other instances of <tt><a>Down</a> a</tt> behave as they do for
--   <tt>a</tt>.
newtype Down a
Down :: a -> Down a

[getDown] :: Down a -> a

-- | <a>IsString</a> is used in combination with the
--   <tt>-XOverloadedStrings</tt> language extension to convert the
--   literals to different string types.
--   
--   For example, if you use the <a>text</a> package, you can say
--   
--   <pre>
--   {-# LANGUAGE OverloadedStrings  #-}
--   
--   myText = "hello world" :: Text
--   </pre>
--   
--   Internally, the extension will convert this to the equivalent of
--   
--   <pre>
--   myText = fromString @Text ("hello world" :: String)
--   </pre>
--   
--   <b>Note:</b> You can use <tt>fromString</tt> in normal code as well,
--   but the usual performance/memory efficiency problems with
--   <a>String</a> apply.
class IsString a
fromString :: IsString a => String -> a

-- | Deprecated, use <a>SPEC</a> directly instead.
--   
--   Annotating a type with <a>NoSpecConstr</a> will make
--   <tt>SpecConstr</tt> not specialise for arguments of that type, e. g.,
--   <tt>{-# ANN type SPEC ForceSpecConstr #-}</tt>.
data SpecConstrAnnotation
NoSpecConstr :: SpecConstrAnnotation
ForceSpecConstr :: SpecConstrAnnotation

-- | The <a>IsList</a> class and its methods are intended to be used in
--   conjunction with the OverloadedLists extension.
class IsList l where {
    
    -- | The <a>Item</a> type function returns the type of items of the
    --   structure <tt>l</tt>.
    type Item l;
}

-- | The <a>fromList</a> function constructs the structure <tt>l</tt> from
--   the given list of <tt>Item l</tt>
fromList :: IsList l => [Item l] -> l

-- | The <a>fromListN</a> function takes the input list's length and
--   potentially uses it to construct the structure <tt>l</tt> more
--   efficiently compared to <a>fromList</a>. If the given number does not
--   equal to the input list's length the behaviour of <a>fromListN</a> is
--   not specified.
--   
--   <pre>
--   fromListN (length xs) xs == fromList xs
--   </pre>
fromListN :: IsList l => Int -> [Item l] -> l

-- | The <a>toList</a> function extracts a list of <tt>Item l</tt> from the
--   structure <tt>l</tt>. It should satisfy fromList . toList = id.
toList :: IsList l => l -> [Item l]

-- | The <a>Item</a> type function returns the type of items of the
--   structure <tt>l</tt>.
type family Item l

-- | <tt><a>dataToTag#</a></tt> evaluates its argument and returns the
--   index (starting at zero) of the constructor used to produce that
--   argument. Any algebraic data type with all of its constructors in
--   scope may be used with <tt>dataToTag#</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; dataToTag# (Left ())
--   0#
--   
--   &gt;&gt;&gt; dataToTag# (Right undefined)
--   1#
--   </pre>
class DataToTag (a :: TYPE 'BoxedRep lev)
dataToTag# :: DataToTag a => a -> Int#

-- | The constraint <tt><a>WithDict</a> cls meth</tt> can be solved when
--   evidence for the constraint <tt>cls</tt> can be provided in the form
--   of a dictionary of type <tt>meth</tt>. This requires <tt>cls</tt> to
--   be a class constraint whose single method has type <tt>meth</tt>.
--   
--   For more (important) details on how this works, see <tt>Note
--   [withDict]</tt> in <a>GHC.Tc.Instance.Class</a> in GHC.
class WithDict cls meth
withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). WithDict cls meth => meth -> (cls => r) -> r

-- | A value of type <tt><a>FunPtr</a> a</tt> is a pointer to a function
--   callable from foreign code. The type <tt>a</tt> will normally be a
--   <i>foreign type</i>, a function type with zero or more arguments where
--   
--   <ul>
--   <li>the argument types are <i>marshallable foreign types</i>, i.e.
--   <a>Char</a>, <a>Int</a>, <a>Double</a>, <a>Float</a>, <a>Bool</a>,
--   <a>Int8</a>, <a>Int16</a>, <a>Int32</a>, <a>Int64</a>, <a>Word8</a>,
--   <a>Word16</a>, <a>Word32</a>, <a>Word64</a>, <tt><a>Ptr</a> a</tt>,
--   <tt><a>FunPtr</a> a</tt>, <tt><a>StablePtr</a> a</tt> or a renaming of
--   any of these using <tt>newtype</tt>.</li>
--   <li>the return type is either a marshallable foreign type or has the
--   form <tt><a>IO</a> t</tt> where <tt>t</tt> is a marshallable foreign
--   type or <tt>()</tt>.</li>
--   </ul>
--   
--   A value of type <tt><a>FunPtr</a> a</tt> may be a pointer to a foreign
--   function, either returned by another foreign function or imported with
--   a a static address import like
--   
--   <pre>
--   foreign import ccall "stdlib.h &amp;free"
--     p_free :: FunPtr (Ptr a -&gt; IO ())
--   </pre>
--   
--   or a pointer to a Haskell function created using a <i>wrapper</i> stub
--   declared to produce a <a>FunPtr</a> of the correct type. For example:
--   
--   <pre>
--   type Compare = Int -&gt; Int -&gt; Bool
--   foreign import ccall "wrapper"
--     mkCompare :: Compare -&gt; IO (FunPtr Compare)
--   </pre>
--   
--   Calls to wrapper stubs like <tt>mkCompare</tt> allocate storage, which
--   should be released with <a>freeHaskellFunPtr</a> when no longer
--   required.
--   
--   To convert <a>FunPtr</a> values to corresponding Haskell functions,
--   one can define a <i>dynamic</i> stub for the specific foreign type,
--   e.g.
--   
--   <pre>
--   type IntFunction = CInt -&gt; IO ()
--   foreign import ccall "dynamic"
--     mkFun :: FunPtr IntFunction -&gt; IntFunction
--   </pre>
data FunPtr a
FunPtr :: Addr# -> FunPtr a

-- | A value of type <tt><a>Ptr</a> a</tt> represents a pointer to an
--   object, or an array of objects, which may be marshalled to or from
--   Haskell values of type <tt>a</tt>.
--   
--   The type <tt>a</tt> will often be an instance of class <a>Storable</a>
--   which provides the marshalling operations. However this is not
--   essential, and you can provide your own operations to access the
--   pointer. For example you might write small foreign functions to get or
--   set the fields of a C <tt>struct</tt>.
data Ptr a
Ptr :: Addr# -> Ptr a
pattern KindRepApp :: () => KindRep -> KindRep -> KindRep
pattern KindRepFun :: () => KindRep -> KindRep -> KindRep
pattern KindRepTYPE :: () => RuntimeRep -> KindRep
pattern KindRepTyConApp :: () => TyCon -> [KindRep] -> KindRep
pattern KindRepTypeLitD :: () => TypeLitSort -> [Char] -> KindRep
pattern KindRepTypeLitS :: () => TypeLitSort -> Addr# -> KindRep
pattern KindRepVar :: () => KindBndr -> KindRep
type family MultMul (a :: Multiplicity) (b :: Multiplicity) :: Multiplicity
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering

-- | <a>SPEC</a> is used by GHC in the <tt>SpecConstr</tt> pass in order to
--   inform the compiler when to be particularly aggressive. In particular,
--   it tells GHC to specialize regardless of size or the number of
--   specializations. However, not all loops fall into this category.
--   
--   Libraries can specify this by using <a>SPEC</a> data type to inform
--   which loops should be aggressively specialized. For example, instead
--   of
--   
--   <pre>
--   loop x where loop arg = ...
--   </pre>
--   
--   write
--   
--   <pre>
--   loop SPEC x where loop !_ arg = ...
--   </pre>
--   
--   There is no semantic difference between <a>SPEC</a> and <a>SPEC2</a>,
--   we just need a type with two constructors lest it is optimised away
--   before <tt>SpecConstr</tt>.
--   
--   This type is reexported from <a>GHC.Exts</a> since GHC 9.0 and
--   <tt>base-4.15</tt>. For compatibility with earlier releases import it
--   from <a>GHC.Internal.Types</a> in <tt>ghc-internal</tt> package.
data SPEC
SPEC :: SPEC
SPEC2 :: SPEC

-- | Dynamic
pattern TrNameD :: () => [Char] -> TrName

-- | Static
pattern TrNameS :: () => Addr# -> TrName
pattern TypeLitChar :: () => TypeLitSort
pattern TypeLitNat :: () => TypeLitSort
pattern TypeLitSymbol :: () => TypeLitSort

-- | <i>Deprecated: Void# is now an alias for the unboxed tuple (# #).</i>
type Void# = (# #)

-- | An arbitrary machine address assumed to point outside the
--   garbage-collected heap.
data Addr# :: TYPE 'AddrRep
data Array# (a :: TYPE 'BoxedRep l) :: UnliftedType

-- | Primitive bytecode type.
data BCO

-- | A boxed, unlifted datatype representing a region of raw memory in the
--   garbage-collected heap, which is not scanned for pointers during
--   garbage collection.
--   
--   It is created by freezing a 'MutableByteArray#' with
--   'unsafeFreezeByteArray#'. Freezing is essentially a no-op, as
--   'MutableByteArray#' and 'ByteArray#' share the same heap structure
--   under the hood.
--   
--   The immutable and mutable variants are commonly used for scenarios
--   requiring high-performance data structures, like <tt>Text</tt>,
--   <tt>Primitive Vector</tt>, <tt>Unboxed Array</tt>, and
--   <tt>ShortByteString</tt>.
--   
--   Another application of fundamental importance is <tt>Integer</tt>,
--   which is backed by 'ByteArray#'.
--   
--   The representation on the heap of a Byte Array is:
--   
--   <pre>
--   +------------+-----------------+-----------------------+
--   |            |                 |                       |
--   |   HEADER   | SIZE (in bytes) |       PAYLOAD         |
--   |            |                 |                       |
--   +------------+-----------------+-----------------------+
--   </pre>
--   
--   To obtain a pointer to actual payload (e.g., for FFI purposes) use
--   'byteArrayContents#' or 'mutableByteArrayContents#'.
--   
--   Alternatively, enabling the <tt>UnliftedFFITypes</tt> extension allows
--   to mention 'ByteArray#' and 'MutableByteArray#' in FFI type signatures
--   directly.
data ByteArray# :: UnliftedType
data CONSTRAINT (a :: RuntimeRep)
data Char# :: TYPE 'WordRep
data Compact# :: UnliftedType
data Double# :: TYPE 'DoubleRep
data DoubleX2# :: TYPE 'VecRep 'Vec2 'DoubleElemRep
data DoubleX4# :: TYPE 'VecRep 'Vec4 'DoubleElemRep
data DoubleX8# :: TYPE 'VecRep 'Vec8 'DoubleElemRep

-- | The builtin function type, written in infix form as <tt>a % m -&gt;
--   b</tt>. Values of this type are functions taking inputs of type
--   <tt>a</tt> and producing outputs of type <tt>b</tt>. The multiplicity
--   of the input is <tt>m</tt>.
--   
--   Note that <tt><tt>FUN</tt> m a b</tt> permits representation
--   polymorphism in both <tt>a</tt> and <tt>b</tt>, so that types like
--   <tt>'Int#' -&gt; 'Int#'</tt> can still be well-kinded.
data FUN
data Float# :: TYPE 'FloatRep
data FloatX16# :: TYPE 'VecRep 'Vec16 'FloatElemRep
data FloatX4# :: TYPE 'VecRep 'Vec4 'FloatElemRep
data FloatX8# :: TYPE 'VecRep 'Vec8 'FloatElemRep
data Int# :: TYPE 'IntRep
data Int16# :: TYPE 'Int16Rep
data Int16X16# :: TYPE 'VecRep 'Vec16 'Int16ElemRep
data Int16X32# :: TYPE 'VecRep 'Vec32 'Int16ElemRep
data Int16X8# :: TYPE 'VecRep 'Vec8 'Int16ElemRep
data Int32# :: TYPE 'Int32Rep
data Int32X16# :: TYPE 'VecRep 'Vec16 'Int32ElemRep
data Int32X4# :: TYPE 'VecRep 'Vec4 'Int32ElemRep
data Int32X8# :: TYPE 'VecRep 'Vec8 'Int32ElemRep
data Int64# :: TYPE 'Int64Rep
data Int64X2# :: TYPE 'VecRep 'Vec2 'Int64ElemRep
data Int64X4# :: TYPE 'VecRep 'Vec4 'Int64ElemRep
data Int64X8# :: TYPE 'VecRep 'Vec8 'Int64ElemRep
data Int8# :: TYPE 'Int8Rep
data Int8X16# :: TYPE 'VecRep 'Vec16 'Int8ElemRep
data Int8X32# :: TYPE 'VecRep 'Vec32 'Int8ElemRep
data Int8X64# :: TYPE 'VecRep 'Vec64 'Int8ElemRep

-- | A shared mutable variable (<i>not</i> the same as a 'MutVar#'!).
--   (Note: in a non-concurrent implementation, <tt>('MVar#' a)</tt> can be
--   represented by <tt>('MutVar#' (Maybe a))</tt>.)
data MVar# a (b :: TYPE 'BoxedRep l) :: UnliftedType

-- | A 'MutVar#' behaves like a single-element mutable array.
data MutVar# a (b :: TYPE 'BoxedRep l) :: UnliftedType
data MutableArray# a (b :: TYPE 'BoxedRep l) :: UnliftedType

-- | A mutable 'ByteAray#'. It can be created in three ways:
--   
--   <ul>
--   <li>'newByteArray#': Create an unpinned array.</li>
--   <li>'newPinnedByteArray#': This will create a pinned array,</li>
--   <li>'newAlignedPinnedByteArray#': This will create a pinned array,
--   with a custom alignment.</li>
--   </ul>
--   
--   Unpinned arrays can be moved around during garbage collection, so you
--   must not store or pass pointers to these values if there is a chance
--   for the garbage collector to kick in. That said, even unpinned arrays
--   can be passed to unsafe FFI calls, because no garbage collection
--   happens during these unsafe calls (see <a>Guaranteed Call Safety</a>
--   in the GHC Manual). For safe FFI calls, byte arrays must be not only
--   pinned, but also kept alive by means of the keepAlive# function for
--   the duration of a call (that's because garbage collection cannot move
--   a pinned array, but is free to scrap it altogether).
data MutableByteArray# a :: UnliftedType

-- | See <a>GHC.Prim#continuations</a>.
data PromptTag# a :: UnliftedType

-- | The type constructor 'Proxy#' is used to bear witness to some type
--   variable. It's used when you want to pass around proxy values for
--   doing things like modelling type applications. A 'Proxy#' is not only
--   unboxed, it also has a polymorphic kind, and has no runtime
--   representation, being totally free.
data Proxy# (a :: k) :: ZeroBitType

-- | <tt>RealWorld</tt> is deeply magical. It is <i>primitive</i>, but it
--   is not <i>unlifted</i> (hence <tt>ptrArg</tt>). We never manipulate
--   values of type <tt>RealWorld</tt>; it's only used in the type system,
--   to parameterise 'State#'.
data RealWorld
data SmallArray# (a :: TYPE 'BoxedRep l) :: UnliftedType
data SmallMutableArray# a (b :: TYPE 'BoxedRep l) :: UnliftedType
data StableName# (a :: TYPE 'BoxedRep l) :: UnliftedType
data StablePtr# (a :: TYPE 'BoxedRep l) :: TYPE 'AddrRep

-- | Haskell representation of a <tt>StgStack*</tt> that was created
--   (cloned) with a function in <a>GHC.Stack.CloneStack</a>. Please check
--   the documentation in that module for more detailed explanations.
data StackSnapshot# :: UnliftedType

-- | 'State#' is the primitive, unlifted type of states. It has one type
--   parameter, thus <tt>'State#' <tt>RealWorld</tt></tt>, or <tt>'State#'
--   s</tt>, where s is a type variable. The only purpose of the type
--   parameter is to keep different state threads separate. It is
--   represented by nothing at all.
data State# a :: ZeroBitType
data TVar# a (b :: TYPE 'BoxedRep l) :: UnliftedType
data TYPE (a :: RuntimeRep)

-- | (In a non-concurrent implementation, this can be a singleton type,
--   whose (unique) value is returned by 'myThreadId#'. The other
--   operations can be omitted.)
data ThreadId# :: UnliftedType
data Weak# (a :: TYPE 'BoxedRep l) :: UnliftedType
data Word# :: TYPE 'WordRep
data Word16# :: TYPE 'Word16Rep
data Word16X16# :: TYPE 'VecRep 'Vec16 'Word16ElemRep
data Word16X32# :: TYPE 'VecRep 'Vec32 'Word16ElemRep
data Word16X8# :: TYPE 'VecRep 'Vec8 'Word16ElemRep
data Word32# :: TYPE 'Word32Rep
data Word32X16# :: TYPE 'VecRep 'Vec16 'Word32ElemRep
data Word32X4# :: TYPE 'VecRep 'Vec4 'Word32ElemRep
data Word32X8# :: TYPE 'VecRep 'Vec8 'Word32ElemRep
data Word64# :: TYPE 'Word64Rep
data Word64X2# :: TYPE 'VecRep 'Vec2 'Word64ElemRep
data Word64X4# :: TYPE 'VecRep 'Vec4 'Word64ElemRep
data Word64X8# :: TYPE 'VecRep 'Vec8 'Word64ElemRep
data Word8# :: TYPE 'Word8Rep
data Word8X16# :: TYPE 'VecRep 'Vec16 'Word8ElemRep
data Word8X32# :: TYPE 'VecRep 'Vec32 'Word8ElemRep
data Word8X64# :: TYPE 'VecRep 'Vec64 'Word8ElemRep

-- | The type constructor <tt>Any :: forall k. k</tt> allows creating an
--   arbitrary type of the given kind.
--   
--   It can be used to create a placeholder type when you only have a kind
--   in hand.
--   
--   You can use <tt>unsafeCoerce#</tt> to unsafely coerce a value from
--   <tt>ty :: k</tt> to <tt>Any @k</tt> and back. As per the documentation
--   of <tt>unsafeCoerce#</tt>, this is only sound if both sides have the
--   <b>exact same</b>runtime representation. Some examples:
--   
--   <pre>
--   unsafeCoerce# True :: (Any :: Type)                -- OK
--   unsafeCoerce# (1# :: Int#) :: (Any :: TYPE IntRep) -- OK
--   unsafeCoerce# True :: (Any :: Type IntRep)         -- INVALID
--   unsafeCoerce  True :: (Any :: UnliftedType)        -- INVALID
--   unsafeCoerce  (ba :: ByteArray#) :: (Any :: Type)  -- INVALID
--   </pre>
--   
--   To avoid accidentally unsafe-coercing between different
--   representations, it is recommended to: - use explicit type annotations
--   or type applications at every use-site of <tt>unsafeCoerce#</tt> - use
--   representation-monomorphic variants such as <tt>unsafeCoerce</tt> or
--   <tt>unsafeCoerceUnlifted</tt>.
--   
--   In particular, this also implies it is safe to round-trip
--   unsafe-coercion via <a>Any</a>, as long as the kinds line up e.g.
--   <tt>unsafeCoerce (unsafeCoerce (val :: a) :: <a>Any</a>) :: a</tt> is
--   safe in that way.
type family Any :: k
data Bool
False :: Bool
True :: Bool

-- | The character type <a>Char</a> represents Unicode codespace and its
--   elements are code points as in definitions <a>D9 and D10 of the
--   Unicode Standard</a>.
--   
--   Character literals in Haskell are single-quoted: <tt>'Q'</tt>,
--   <tt>'Я'</tt> or <tt>'Ω'</tt>. To represent a single quote itself use
--   <tt>'\''</tt>, and to represent a backslash use <tt>'\\'</tt>. The
--   full grammar can be found in the section 2.6 of the <a>Haskell 2010
--   Language Report</a>.
--   
--   To specify a character by its code point one can use decimal,
--   hexadecimal or octal notation: <tt>'\65'</tt>, <tt>'\x41'</tt> and
--   <tt>'\o101'</tt> are all alternative forms of <tt>'A'</tt>. The
--   largest code point is <tt>'\x10ffff'</tt>.
--   
--   There is a special escape syntax for ASCII control characters:
--   
--   TODO: table
--   
--   <a>Data.Char</a> provides utilities to work with <a>Char</a>.
data Char
C# :: Char# -> Char

-- | <tt>Coercible</tt> is a two-parameter class that has instances for
--   types <tt>a</tt> and <tt>b</tt> if the compiler can infer that they
--   have the same representation. This class does not have regular
--   instances; instead they are created on-the-fly during type-checking.
--   Trying to manually declare an instance of <tt>Coercible</tt> is an
--   error.
--   
--   Nevertheless one can pretend that the following three kinds of
--   instances exist. First, as a trivial base-case:
--   
--   <pre>
--   instance Coercible a a
--   </pre>
--   
--   Furthermore, for every type constructor there is an instance that
--   allows to coerce under the type constructor. For example, let
--   <tt>D</tt> be a prototypical type constructor (<tt>data</tt> or
--   <tt>newtype</tt>) with three type arguments, which have roles
--   <tt>nominal</tt>, <tt>representational</tt> resp. <tt>phantom</tt>.
--   Then there is an instance of the form
--   
--   <pre>
--   instance Coercible b b' =&gt; Coercible (D a b c) (D a b' c')
--   </pre>
--   
--   Note that the <tt>nominal</tt> type arguments are equal, the
--   <tt>representational</tt> type arguments can differ, but need to have
--   a <tt>Coercible</tt> instance themself, and the <tt>phantom</tt> type
--   arguments can be changed arbitrarily.
--   
--   The third kind of instance exists for every <tt>newtype NT = MkNT
--   T</tt> and comes in two variants, namely
--   
--   <pre>
--   instance Coercible a T =&gt; Coercible a NT
--   </pre>
--   
--   <pre>
--   instance Coercible T b =&gt; Coercible NT b
--   </pre>
--   
--   This instance is only usable if the constructor <tt>MkNT</tt> is in
--   scope.
--   
--   If, as a library author of a type constructor like <tt>Set a</tt>, you
--   want to prevent a user of your module to write <tt>coerce :: Set T
--   -&gt; Set NT</tt>, you need to set the role of <tt>Set</tt>'s type
--   parameter to <tt>nominal</tt>, by writing
--   
--   <pre>
--   type role Set nominal
--   </pre>
--   
--   For more details about this feature, please refer to <a>Safe
--   Coercions</a> by Joachim Breitner, Richard A. Eisenberg, Simon Peyton
--   Jones and Stephanie Weirich.
class a ~R# b => Coercible (a :: k) (b :: k)

-- | The kind of lifted constraints
type Constraint = CONSTRAINT LiftedRep

-- | Data type <tt>Dict</tt> provides a simple way to wrap up a (lifted)
--   constraint as a type
data DictBox a
MkDictBox :: DictBox a

-- | Double-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   double-precision type.
data Double
D# :: Double# -> Double
data DoubleBox (a :: TYPE 'DoubleRep)
MkDoubleBox :: a -> DoubleBox (a :: TYPE 'DoubleRep)

-- | Single-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   single-precision type.
data Float
F# :: Float# -> Float
data FloatBox (a :: TYPE 'FloatRep)
MkFloatBox :: a -> FloatBox (a :: TYPE 'FloatRep)

-- | A fixed-precision integer type with at least the range <tt>[-2^29 ..
--   2^29-1]</tt>. The exact range for a given implementation can be
--   determined by using <a>minBound</a> and <a>maxBound</a> from the
--   <a>Bounded</a> class.
data Int
I# :: Int# -> Int
data IntBox (a :: TYPE 'IntRep)
MkIntBox :: a -> IntBox (a :: TYPE 'IntRep)

-- | Whether a boxed type is lifted or unlifted.
data Levity
Lifted :: Levity
Unlifted :: Levity

-- | The runtime representation of lifted types.
type LiftedRep = 'BoxedRep 'Lifted

-- | The builtin linked list type.
--   
--   In Haskell, lists are one of the most important data types as they are
--   often used analogous to loops in imperative programming languages.
--   These lists are singly linked, which makes them unsuited for
--   operations that require &lt;math&gt; access. Instead, they are
--   intended to be traversed.
--   
--   You can use <tt>List a</tt> or <tt>[a]</tt> in type signatures:
--   
--   <pre>
--   length :: [a] -&gt; Int
--   </pre>
--   
--   or
--   
--   <pre>
--   length :: List a -&gt; Int
--   </pre>
--   
--   They are fully equivalent, and <tt>List a</tt> will be normalised to
--   <tt>[a]</tt>.
--   
--   <h4>Usage</h4>
--   
--   Lists are constructed recursively using the right-associative
--   constructor operator (or <i>cons</i>) <tt>(:) :: a -&gt; [a] -&gt;
--   [a]</tt>, which prepends an element to a list, and the empty list
--   <tt>[]</tt>.
--   
--   <pre>
--   (1 : 2 : 3 : []) == (1 : (2 : (3 : []))) == [1, 2, 3]
--   </pre>
--   
--   Lists can also be constructed using list literals of the form
--   <tt>[x_1, x_2, ..., x_n]</tt> which are syntactic sugar and, unless
--   <tt>-XOverloadedLists</tt> is enabled, are translated into uses of
--   <tt>(:)</tt> and <tt>[]</tt>
--   
--   <a>String</a> literals, like <tt>"I 💜 hs"</tt>, are translated into
--   Lists of characters, <tt>['I', ' ', '💜', ' ', 'h', 's']</tt>.
--   
--   <h4><b>Implementation</b></h4>
--   
--   Internally and in memory, all the above are represented like this,
--   with arrows being pointers to locations in memory.
--   
--   <pre>
--   ╭───┬───┬──╮   ╭───┬───┬──╮   ╭───┬───┬──╮   ╭────╮
--   │(:)│   │ ─┼──&gt;│(:)│   │ ─┼──&gt;│(:)│   │ ─┼──&gt;│ [] │
--   ╰───┴─┼─┴──╯   ╰───┴─┼─┴──╯   ╰───┴─┼─┴──╯   ╰────╯
--         v              v              v
--         1              2              3
--   </pre>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ['H', 'a', 's', 'k', 'e', 'l', 'l']
--   "Haskell"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 1 : [4, 1, 5, 9]
--   [1,4,1,5,9]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; [] : [] : []
--   [[],[]]
--   </pre>
data [] a
data Multiplicity
One :: Multiplicity
Many :: Multiplicity

-- | GHC maintains a property that the kind of all inhabited types (as
--   distinct from type constructors or type-level data) tells us the
--   runtime representation of values of that type. This datatype encodes
--   the choice of runtime value. Note that <a>TYPE</a> is parameterised by
--   <a>RuntimeRep</a>; this is precisely what we mean by the fact that a
--   type's kind encodes the runtime representation.
--   
--   For boxed values (that is, values that are represented by a pointer),
--   a further distinction is made, between lifted types (that contain ⊥),
--   and unlifted ones (that don't).
data RuntimeRep

-- | a SIMD vector type
VecRep :: VecCount -> VecElem -> RuntimeRep

-- | An unboxed tuple of the given reps
TupleRep :: [RuntimeRep] -> RuntimeRep

-- | An unboxed sum of the given reps
SumRep :: [RuntimeRep] -> RuntimeRep

-- | boxed; represented by a pointer
BoxedRep :: Levity -> RuntimeRep

-- | signed, word-sized value
IntRep :: RuntimeRep

-- | signed, 8-bit value
Int8Rep :: RuntimeRep

-- | signed, 16-bit value
Int16Rep :: RuntimeRep

-- | signed, 32-bit value
Int32Rep :: RuntimeRep

-- | signed, 64-bit value
Int64Rep :: RuntimeRep

-- | unsigned, word-sized value
WordRep :: RuntimeRep

-- | unsigned, 8-bit value
Word8Rep :: RuntimeRep

-- | unsigned, 16-bit value
Word16Rep :: RuntimeRep

-- | unsigned, 32-bit value
Word32Rep :: RuntimeRep

-- | unsigned, 64-bit value
Word64Rep :: RuntimeRep

-- | A pointer, but <i>not</i> to a Haskell value
AddrRep :: RuntimeRep

-- | a 32-bit floating point number
FloatRep :: RuntimeRep

-- | a 64-bit floating point number
DoubleRep :: RuntimeRep
pattern MkSolo# :: () => a -> Solo# a

-- | (Kind) This is the kind of type-level symbols.
data Symbol

-- | The runtime representation of unlifted types.
type UnliftedRep = 'BoxedRep 'Unlifted

-- | The kind of boxed, unlifted values, for example <tt>Array#</tt> or a
--   user-defined unlifted data type, using <tt>-XUnliftedDataTypes</tt>.
type UnliftedType = TYPE UnliftedRep

-- | Length of a SIMD vector type
data VecCount
Vec2 :: VecCount
Vec4 :: VecCount
Vec8 :: VecCount
Vec16 :: VecCount
Vec32 :: VecCount
Vec64 :: VecCount

-- | Element of a SIMD vector type
data VecElem
Int8ElemRep :: VecElem
Int16ElemRep :: VecElem
Int32ElemRep :: VecElem
Int64ElemRep :: VecElem
Word8ElemRep :: VecElem
Word16ElemRep :: VecElem
Word32ElemRep :: VecElem
Word64ElemRep :: VecElem
FloatElemRep :: VecElem
DoubleElemRep :: VecElem

-- | A <a>Word</a> is an unsigned integral type, with the same size as
--   <a>Int</a>.
data Word
W# :: Word# -> Word
data WordBox (a :: TYPE 'WordRep)
MkWordBox :: a -> WordBox (a :: TYPE 'WordRep)

-- | The runtime representation of a zero-width tuple, represented by no
--   bits at all
type ZeroBitRep = 'TupleRep '[] :: [RuntimeRep]

-- | The kind of the empty unboxed tuple type (# #)
type ZeroBitType = TYPE ZeroBitRep

-- | Lifted, homogeneous equality. By lifted, we mean that it can be bogus
--   (deferred type error). By homogeneous, the two types <tt>a</tt> and
--   <tt>b</tt> must have the same kinds.
class a ~# b => (a :: k) ~ (b :: k)
infix 4 ~

-- | Lifted, heterogeneous equality. By lifted, we mean that it can be
--   bogus (deferred type error). By heterogeneous, the two types
--   <tt>a</tt> and <tt>b</tt> might have different kinds. Because
--   <tt>~~</tt> can appear unexpectedly in error messages to users who do
--   not care about the difference between heterogeneous equality
--   <tt>~~</tt> and homogeneous equality <tt>~</tt>, this is printed as
--   <tt>~</tt> unless <tt>-fprint-equality-relations</tt> is set.
--   
--   In <tt>0.7.0</tt>, the fixity was set to <tt>infix 4</tt> to match the
--   fixity of <a>:~~:</a>.
class a ~# b => (a :: k0) ~~ (b :: k1)
infix 4 ~~

module GHC.Profiling.Eras

-- | Set the heap profiling era, setting the era to 0 will stop closures
--   being counted.
setUserEra :: Word -> IO ()

-- | Query the profiling era
getUserEra :: IO Word

-- | Increment the era by a given amount, and return the new era.
incrementUserEra :: Word -> IO Word


-- | <i>The API of this module is unstable and is coupled to GHC's
--   internals.</i> As such if you depend on it, you should expect to
--   follow GHC's releases. This API could change without warning.
--   
--   Descriptions of flags can be seen in <a>GHC User's Guide</a>, or by
--   running RTS help message using <tt>+RTS --help</tt>.
module GHC.RTS.Flags.Experimental

-- | <a>RtsTime</a> is defined as a <tt>StgWord64</tt> in
--   <tt>stg/Types.h</tt>
type RtsTime = Word64

-- | Parameters of the runtime system
data RTSFlags
RTSFlags :: GCFlags -> ConcFlags -> MiscFlags -> DebugFlags -> CCFlags -> ProfFlags -> TraceFlags -> TickyFlags -> ParFlags -> HpcFlags -> RTSFlags
[gcFlags] :: RTSFlags -> GCFlags
[concurrentFlags] :: RTSFlags -> ConcFlags
[miscFlags] :: RTSFlags -> MiscFlags
[debugFlags] :: RTSFlags -> DebugFlags
[costCentreFlags] :: RTSFlags -> CCFlags
[profilingFlags] :: RTSFlags -> ProfFlags
[traceFlags] :: RTSFlags -> TraceFlags
[tickyFlags] :: RTSFlags -> TickyFlags
[parFlags] :: RTSFlags -> ParFlags
[hpcFlags] :: RTSFlags -> HpcFlags

-- | Should we produce a summary of the garbage collector statistics after
--   the program has exited?
data GiveGCStats
NoGCStats :: GiveGCStats
CollectGCStats :: GiveGCStats
OneLineGCStats :: GiveGCStats
SummaryGCStats :: GiveGCStats
VerboseGCStats :: GiveGCStats

-- | Parameters of the garbage collector.
data GCFlags
GCFlags :: Maybe FilePath -> GiveGCStats -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Bool -> Double -> Double -> Double -> Word32 -> Bool -> Bool -> Double -> Bool -> Bool -> RtsTime -> Bool -> Word -> Word -> Bool -> Word -> GCFlags
[statsFile] :: GCFlags -> Maybe FilePath
[giveStats] :: GCFlags -> GiveGCStats
[maxStkSize] :: GCFlags -> Word32
[initialStkSize] :: GCFlags -> Word32
[stkChunkSize] :: GCFlags -> Word32
[stkChunkBufferSize] :: GCFlags -> Word32
[maxHeapSize] :: GCFlags -> Word32
[minAllocAreaSize] :: GCFlags -> Word32
[largeAllocLim] :: GCFlags -> Word32
[nurseryChunkSize] :: GCFlags -> Word32
[minOldGenSize] :: GCFlags -> Word32
[heapSizeSuggestion] :: GCFlags -> Word32
[heapSizeSuggestionAuto] :: GCFlags -> Bool
[oldGenFactor] :: GCFlags -> Double
[returnDecayFactor] :: GCFlags -> Double
[pcFreeHeap] :: GCFlags -> Double
[generations] :: GCFlags -> Word32
[squeezeUpdFrames] :: GCFlags -> Bool

-- | True <a>=</a> "compact all the time"
[compact] :: GCFlags -> Bool
[compactThreshold] :: GCFlags -> Double

-- | use "mostly mark-sweep" instead of copying for the oldest generation
[sweep] :: GCFlags -> Bool
[ringBell] :: GCFlags -> Bool
[idleGCDelayTime] :: GCFlags -> RtsTime
[doIdleGC] :: GCFlags -> Bool

-- | address to ask the OS for memory
[heapBase] :: GCFlags -> Word
[allocLimitGrace] :: GCFlags -> Word
[numa] :: GCFlags -> Bool
[numaMask] :: GCFlags -> Word

-- | Parameters concerning context switching
data ConcFlags
ConcFlags :: RtsTime -> Int -> ConcFlags
[ctxtSwitchTime] :: ConcFlags -> RtsTime
[ctxtSwitchTicks] :: ConcFlags -> Int

-- | Miscellaneous parameters
data MiscFlags
MiscFlags :: RtsTime -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Word -> IoManagerFlag -> Word32 -> MiscFlags
[tickInterval] :: MiscFlags -> RtsTime
[installSignalHandlers] :: MiscFlags -> Bool
[installSEHHandlers] :: MiscFlags -> Bool
[generateCrashDumpFile] :: MiscFlags -> Bool
[generateStackTrace] :: MiscFlags -> Bool
[machineReadable] :: MiscFlags -> Bool
[disableDelayedOsMemoryReturn] :: MiscFlags -> Bool
[internalCounters] :: MiscFlags -> Bool
[linkerAlwaysPic] :: MiscFlags -> Bool

-- | address to ask the OS for memory for the linker, 0 ==&gt; off
[linkerMemBase] :: MiscFlags -> Word
[ioManager] :: MiscFlags -> IoManagerFlag
[numIoWorkerThreads] :: MiscFlags -> Word32

data IoManagerFlag
IoManagerFlagAuto :: IoManagerFlag

-- | Unix only, non-threaded RTS only
IoManagerFlagSelect :: IoManagerFlag

-- | cross-platform, threaded RTS only
IoManagerFlagMIO :: IoManagerFlag

-- | Windows only
IoManagerFlagWinIO :: IoManagerFlag

-- | Windows only, non-threaded RTS only
IoManagerFlagWin32Legacy :: IoManagerFlag

-- | Flags to control debugging output &amp; extra checking in various
--   subsystems.
data DebugFlags
DebugFlags :: Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> DebugFlags

-- | <pre>
--   s
--   </pre>
[scheduler] :: DebugFlags -> Bool

-- | <pre>
--   i
--   </pre>
[interpreter] :: DebugFlags -> Bool

-- | <pre>
--   w
--   </pre>
[weak] :: DebugFlags -> Bool

-- | <pre>
--   G
--   </pre>
[gccafs] :: DebugFlags -> Bool

-- | <pre>
--   g
--   </pre>
[gc] :: DebugFlags -> Bool

-- | <pre>
--   n
--   </pre>
[nonmoving_gc] :: DebugFlags -> Bool

-- | <pre>
--   b
--   </pre>
[block_alloc] :: DebugFlags -> Bool

-- | <pre>
--   S
--   </pre>
[sanity] :: DebugFlags -> Bool

-- | <pre>
--   t
--   </pre>
[stable] :: DebugFlags -> Bool

-- | <pre>
--   p
--   </pre>
[prof] :: DebugFlags -> Bool

-- | <tt>l</tt> the object linker
[linker] :: DebugFlags -> Bool

-- | <pre>
--   a
--   </pre>
[apply] :: DebugFlags -> Bool

-- | <pre>
--   m
--   </pre>
[stm] :: DebugFlags -> Bool

-- | <tt>z</tt> stack squeezing &amp; lazy blackholing
[squeeze] :: DebugFlags -> Bool

-- | <tt>c</tt> coverage
[hpc] :: DebugFlags -> Bool

-- | <pre>
--   r
--   </pre>
[sparks] :: DebugFlags -> Bool

-- | Should the RTS produce a cost-center summary?
data DoCostCentres
CostCentresNone :: DoCostCentres
CostCentresSummary :: DoCostCentres
CostCentresVerbose :: DoCostCentres
CostCentresAll :: DoCostCentres
CostCentresJSON :: DoCostCentres

-- | Parameters pertaining to the cost-center profiler.
data CCFlags
CCFlags :: DoCostCentres -> Int -> Int -> CCFlags
[doCostCentres] :: CCFlags -> DoCostCentres
[profilerTicks] :: CCFlags -> Int
[msecsPerTick] :: CCFlags -> Int

-- | What sort of heap profile are we collecting?
data DoHeapProfile
NoHeapProfiling :: DoHeapProfile
HeapByCCS :: DoHeapProfile
HeapByMod :: DoHeapProfile
HeapByDescr :: DoHeapProfile
HeapByType :: DoHeapProfile
HeapByRetainer :: DoHeapProfile
HeapByLDV :: DoHeapProfile
HeapByClosureType :: DoHeapProfile
HeapByInfoTable :: DoHeapProfile

HeapByEra :: DoHeapProfile

-- | Parameters of the cost-center profiler
data ProfFlags
ProfFlags :: DoHeapProfile -> RtsTime -> Word -> Bool -> Bool -> Bool -> Bool -> Word -> Word -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Word -> ProfFlags
[doHeapProfile] :: ProfFlags -> DoHeapProfile

-- | time between samples
[heapProfileInterval] :: ProfFlags -> RtsTime

-- | ticks between samples (derived)
[heapProfileIntervalTicks] :: ProfFlags -> Word
[startHeapProfileAtStartup] :: ProfFlags -> Bool

[startTimeProfileAtStartup] :: ProfFlags -> Bool
[showCCSOnException] :: ProfFlags -> Bool

[automaticEraIncrement] :: ProfFlags -> Bool
[maxRetainerSetSize] :: ProfFlags -> Word
[ccsLength] :: ProfFlags -> Word
[modSelector] :: ProfFlags -> Maybe String
[descrSelector] :: ProfFlags -> Maybe String
[typeSelector] :: ProfFlags -> Maybe String
[ccSelector] :: ProfFlags -> Maybe String
[ccsSelector] :: ProfFlags -> Maybe String
[retainerSelector] :: ProfFlags -> Maybe String
[bioSelector] :: ProfFlags -> Maybe String

[eraSelector] :: ProfFlags -> Word

-- | Is event tracing enabled?
data DoTrace

-- | no tracing
TraceNone :: DoTrace

-- | send tracing events to the event log
TraceEventLog :: DoTrace

-- | send tracing events to <tt>stderr</tt>
TraceStderr :: DoTrace

-- | Parameters pertaining to event tracing
data TraceFlags
TraceFlags :: DoTrace -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> TraceFlags
[tracing] :: TraceFlags -> DoTrace

-- | show timestamp in stderr output
[timestamp] :: TraceFlags -> Bool

-- | trace scheduler events
[traceScheduler] :: TraceFlags -> Bool

-- | trace GC events
[traceGc] :: TraceFlags -> Bool

-- | trace nonmoving GC heap census samples
[traceNonmovingGc] :: TraceFlags -> Bool

-- | trace spark events by a sampled method
[sparksSampled] :: TraceFlags -> Bool

-- | trace spark events 100% accurately
[sparksFull] :: TraceFlags -> Bool

-- | trace user events (emitted from Haskell code)
[user] :: TraceFlags -> Bool

-- | Parameters pertaining to ticky-ticky profiler
data TickyFlags
TickyFlags :: Bool -> Maybe FilePath -> TickyFlags
[showTickyStats] :: TickyFlags -> Bool
[tickyFile] :: TickyFlags -> Maybe FilePath

-- | Parameters pertaining to parallelism
data ParFlags
ParFlags :: Word32 -> Bool -> Word32 -> Bool -> Word32 -> Bool -> Word32 -> Word32 -> Word32 -> Bool -> ParFlags
[nCapabilities] :: ParFlags -> Word32
[migrate] :: ParFlags -> Bool
[maxLocalSparks] :: ParFlags -> Word32
[parGcEnabled] :: ParFlags -> Bool
[parGcGen] :: ParFlags -> Word32
[parGcLoadBalancingEnabled] :: ParFlags -> Bool
[parGcLoadBalancingGen] :: ParFlags -> Word32
[parGcNoSyncWithIdle] :: ParFlags -> Word32
[parGcThreads] :: ParFlags -> Word32
[setAffinity] :: ParFlags -> Bool

-- | Parameters pertaining to Haskell program coverage (HPC)
data HpcFlags
HpcFlags :: Bool -> Bool -> HpcFlags

-- | Controls whether a <tt><a>program</a>.tix</tt> file is read at the
--   start of execution to initialize the RTS internal HPC datastructures.
[readTixFile] :: HpcFlags -> Bool

-- | Controls whether the <tt><a>program</a>.tix</tt> file should be
--   written after the execution of the program.
[writeTixFile] :: HpcFlags -> Bool

-- | The I/O SubSystem to use in the program.
data IoSubSystem

-- | Use a POSIX I/O Sub-System
IoPOSIX :: IoSubSystem

-- | Use platform native Sub-System. For unix OSes this is the same as
--   IoPOSIX, but on Windows this means use the Windows native APIs for
--   I/O, including IOCP and RIO.
IoNative :: IoSubSystem
getRTSFlags :: IO RTSFlags
getGCFlags :: IO GCFlags
getConcFlags :: IO ConcFlags
getMiscFlags :: IO MiscFlags
getDebugFlags :: IO DebugFlags
getCCFlags :: IO CCFlags
getProfFlags :: IO ProfFlags
getTraceFlags :: IO TraceFlags
getTickyFlags :: IO TickyFlags
getParFlags :: IO ParFlags
getHpcFlags :: IO HpcFlags


-- | Push user-defined annotation stack frames into the Haskell call stack.
--   Annotation stack frames may be decoded when unwinding the call stack,
--   allowing the user to gain more control over what an IPE stack trace
--   looks like.
--   
--   The main advantages of stack frame annotations over other
--   <tt>Backtraces</tt>:
--   
--   <ul>
--   <li>Function signatures don't need to be modified to improve stack
--   traces (e.g. via <a>HasCallStack</a>).</li>
--   <li>Annotation are arbitrary user-defined datatypes, not just source
--   locations.</li>
--   <li>Stack frame annotations are always present and do not require
--   recompilation (e.g. <tt>-prof</tt> or <tt>-g3</tt>).</li>
--   </ul>
module GHC.Stack.Annotation.Experimental

-- | The <tt>SomeStackAnnotation</tt> type is the root of the stack
--   annotation type hierarchy. When the call stack is annotated with a
--   value of type <tt>a</tt>, behind the scenes it is encapsulated in a
--   <tt>SomeStackAnnotation</tt>.
data SomeStackAnnotation
[SomeStackAnnotation] :: forall a. (Typeable a, StackAnnotation a) => a -> SomeStackAnnotation

-- | <a>StackAnnotation</a>s are types which can be pushed onto the call
--   stack as the payload of <tt>AnnFrame</tt> stack frames.
class StackAnnotation a

-- | Display a human readable string for the <a>StackAnnotation</a>.
--   
--   This is supposed to be the long version of
--   <a>displayStackAnnotationShort</a> and may contain a source location.
--   
--   If not provided, <a>displayStackAnnotation</a> is derived from
--   <a>stackAnnotationSourceLocation</a> and
--   <a>displayStackAnnotationShort</a>.
displayStackAnnotation :: StackAnnotation a => a -> String

-- | Get the <a>SrcLoc</a> of the given <a>StackAnnotation</a>.
--   
--   This is optional, <a>SrcLoc</a> are not strictly required for
--   <a>StackAnnotation</a>, but it is still heavily encouarged to provide
--   a <a>SrcLoc</a> for better IPE backtraces.
stackAnnotationSourceLocation :: StackAnnotation a => a -> Maybe SrcLoc

-- | The description of the StackAnnotation without any metadata such as
--   source locations.
--   
--   Pefer implementing <a>displayStackAnnotationShort</a> over
--   <a>displayStackAnnotation</a>.
displayStackAnnotationShort :: StackAnnotation a => a -> String

-- | Use the <a>Show</a> instance of a type to display as the
--   <a>StackAnnotation</a>.
data ShowAnnotation
[ShowAnnotation] :: forall a. Show a => Maybe SrcLoc -> a -> ShowAnnotation

-- | A <a>String</a> only annotation with an optional source location.
data StringAnnotation
[StringAnnotation] :: Maybe SrcLoc -> String -> StringAnnotation

-- | A <a>CallStack</a> stack annotation.
--   
--   Captures the whole <a>CallStack</a>.
newtype CallStackAnnotation
CallStackAnnotation :: CallStack -> CallStackAnnotation

-- | <tt><a>annotateStackIO</a> showable b</tt> annotates the evaluation
--   stack of <tt>b</tt> with the value <tt>showable</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
annotateStackIO :: (HasCallStack, Typeable a, StackAnnotation a) => a -> IO b -> IO b

-- | <tt><a>annotateStackStringIO</a> msg b</tt> annotates the evaluation
--   stack of <tt>b</tt> with the value <tt>msg</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
annotateStackStringIO :: HasCallStack => String -> IO b -> IO b

-- | <tt><a>annotateStackShowIO</a> msg b</tt> annotates the evaluation
--   stack of <tt>b</tt> with the value <tt>msg</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
annotateStackShowIO :: (HasCallStack, Show a) => a -> IO b -> IO b

-- | <tt><a>annotateCallStackIO</a> b</tt> annotates the evaluation stack
--   of <tt>b</tt> with the current <tt>callstack</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
annotateCallStackIO :: HasCallStack => IO a -> IO a

-- | <tt><a>annotateStack</a> anno b</tt> annotates the evaluation stack of
--   <tt>b</tt> with the value of <tt>anno</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
--   
--   WARNING: forces the evaluation of <tt>b</tt> to WHNF.
annotateStack :: (HasCallStack, Typeable a, StackAnnotation a) => a -> b -> b

-- | <tt><a>annotateStackString</a> msg b</tt> annotates the evaluation
--   stack of <tt>b</tt> with the value <tt>msg</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
--   
--   WARNING: forces the evaluation of <tt>b</tt> to WHNF.
annotateStackString :: HasCallStack => String -> b -> b

-- | <tt><a>annotateStackShow</a> showable b</tt> annotates the evaluation
--   stack of <tt>b</tt> with the value <tt>showable</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
--   
--   WARNING: forces the evaluation of <tt>b</tt> to WHNF.
annotateStackShow :: (HasCallStack, Typeable a, Show a) => a -> b -> b

-- | <tt><a>annotateCallStack</a> b</tt> annotates the evaluation stack of
--   <tt>b</tt> with the current <tt>callstack</tt>.
--   
--   When decoding the call stack, the annotation frames can be used to add
--   more information to stack traces.
--   
--   WARNING: forces the evaluation of <tt>b</tt> to WHNF.
annotateCallStack :: HasCallStack => b -> b
instance GHC.Internal.Show.Show GHC.Stack.Annotation.Experimental.CallStackAnnotation
instance GHC.Internal.Stack.Annotation.StackAnnotation GHC.Stack.Annotation.Experimental.CallStackAnnotation
instance GHC.Internal.Stack.Annotation.StackAnnotation GHC.Stack.Annotation.Experimental.ShowAnnotation
instance GHC.Internal.Stack.Annotation.StackAnnotation GHC.Stack.Annotation.Experimental.StringAnnotation

module GHC.Stack.Decode.Experimental
decodeStackWithIpe :: StackSnapshot -> IO [(StackFrame, Maybe InfoProv)]
decodeStackWithFrameUnpack :: (StackFrameLocation -> IO a) -> StackSnapshot -> IO (StgInfoTable, [a])

-- | Representation for the source location where a return frame was pushed
--   on the stack. This happens every time when a <tt>case ... of</tt>
--   scrutinee is evaluated.
data StackEntry
StackEntry :: String -> String -> String -> ClosureType -> StackEntry
[functionName] :: StackEntry -> String
[moduleName] :: StackEntry -> String
[srcLoc] :: StackEntry -> String
[closureType] :: StackEntry -> ClosureType
prettyStackFrameWithIpe :: (StackFrame, Maybe InfoProv) -> Maybe String
prettyStackEntry :: StackEntry -> String


-- | This module provides access to internal garbage collection and memory
--   usage statistics. These statistics are not available unless a program
--   is run with the <tt>-T</tt> RTS flag.
--   
--   <i>The API of this module is unstable and is coupled to GHC's
--   internals.</i> As such if you depend on it, you should expect to
--   follow GHC's releases. This API could change without warning.
module GHC.Stats.Experimental

-- | Statistics about runtime activity since the start of the program. This
--   is a mirror of the C <tt>struct RTSStats</tt> in <tt>RtsAPI.h</tt>
data RTSStats
RTSStats :: Word32 -> Word32 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> GCDetails -> RTSStats

-- | Total number of GCs
[gcs] :: RTSStats -> Word32

-- | Total number of major (oldest generation) GCs
[major_gcs] :: RTSStats -> Word32

-- | Total bytes allocated
[allocated_bytes] :: RTSStats -> Word64

-- | Maximum live data (including large objects + compact regions) in the
--   heap. Updated after a major GC.
[max_live_bytes] :: RTSStats -> Word64

-- | Maximum live data in large objects
[max_large_objects_bytes] :: RTSStats -> Word64

-- | Maximum live data in compact regions
[max_compact_bytes] :: RTSStats -> Word64

-- | Maximum slop
[max_slop_bytes] :: RTSStats -> Word64

-- | Maximum memory in use by the RTS
[max_mem_in_use_bytes] :: RTSStats -> Word64

-- | Sum of live bytes across all major GCs. Divided by major_gcs gives the
--   average live data over the lifetime of the program.
[cumulative_live_bytes] :: RTSStats -> Word64

-- | Sum of copied_bytes across all GCs
[copied_bytes] :: RTSStats -> Word64

-- | Sum of copied_bytes across all parallel GCs
[par_copied_bytes] :: RTSStats -> Word64

-- | Sum of par_max_copied_bytes across all parallel GCs. Deprecated.
[cumulative_par_max_copied_bytes] :: RTSStats -> Word64

-- | Sum of par_balanced_copied bytes across all parallel GCs
[cumulative_par_balanced_copied_bytes] :: RTSStats -> Word64

-- | Total CPU time used by the init phase @since base-4.12.0.0
[init_cpu_ns] :: RTSStats -> RtsTime

-- | Total elapsed time used by the init phase @since base-4.12.0.0
[init_elapsed_ns] :: RTSStats -> RtsTime

-- | Total CPU time used by the mutator
[mutator_cpu_ns] :: RTSStats -> RtsTime

-- | Total elapsed time used by the mutator
[mutator_elapsed_ns] :: RTSStats -> RtsTime

-- | Total CPU time used by the GC
[gc_cpu_ns] :: RTSStats -> RtsTime

-- | Total elapsed time used by the GC
[gc_elapsed_ns] :: RTSStats -> RtsTime

-- | Total elapsed time used during GC synchronization
[gc_sync_elapsed_ns] :: RTSStats -> RtsTime

-- | Total CPU time (at the previous GC)
[cpu_ns] :: RTSStats -> RtsTime

-- | Total elapsed time (at the previous GC)
[elapsed_ns] :: RTSStats -> RtsTime

-- | The total CPU time used during the post-mark pause phase of the
--   concurrent nonmoving GC.
[nonmoving_gc_sync_cpu_ns] :: RTSStats -> RtsTime

-- | The total time elapsed during the post-mark pause phase of the
--   concurrent nonmoving GC.
[nonmoving_gc_sync_elapsed_ns] :: RTSStats -> RtsTime

-- | The maximum elapsed length of any post-mark pause phase of the
--   concurrent nonmoving GC.
[nonmoving_gc_sync_max_elapsed_ns] :: RTSStats -> RtsTime

-- | The total CPU time used by the nonmoving GC.
[nonmoving_gc_cpu_ns] :: RTSStats -> RtsTime

-- | The total time elapsed during which there is a nonmoving GC active.
[nonmoving_gc_elapsed_ns] :: RTSStats -> RtsTime

-- | The maximum time elapsed during any nonmoving GC cycle.
[nonmoving_gc_max_elapsed_ns] :: RTSStats -> RtsTime

-- | Details about the most recent GC
[gc] :: RTSStats -> GCDetails

-- | Statistics about a single GC. This is a mirror of the C <tt>struct
--   GCDetails</tt> in <tt>RtsAPI.h</tt>, with the field prefixed with
--   <tt>gc_</tt> to avoid collisions with <a>RTSStats</a>.
data GCDetails
GCDetails :: Word32 -> Word32 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> RtsTime -> GCDetails

-- | The generation number of this GC
[gcdetails_gen] :: GCDetails -> Word32

-- | Number of threads used in this GC
[gcdetails_threads] :: GCDetails -> Word32

-- | Number of bytes allocated since the previous GC
[gcdetails_allocated_bytes] :: GCDetails -> Word64

-- | Total amount of live data in the heap (includes large + compact data).
--   Updated after every GC. Data in uncollected generations (in minor GCs)
--   are considered live.
[gcdetails_live_bytes] :: GCDetails -> Word64

-- | Total amount of live data in large objects
[gcdetails_large_objects_bytes] :: GCDetails -> Word64

-- | Total amount of live data in compact regions
[gcdetails_compact_bytes] :: GCDetails -> Word64

-- | Total amount of slop (wasted memory)
[gcdetails_slop_bytes] :: GCDetails -> Word64

-- | Total amount of memory in use by the RTS
[gcdetails_mem_in_use_bytes] :: GCDetails -> Word64

-- | Total amount of data copied during this GC
[gcdetails_copied_bytes] :: GCDetails -> Word64

-- | In parallel GC, the max amount of data copied by any one thread.
--   Deprecated.
[gcdetails_par_max_copied_bytes] :: GCDetails -> Word64

-- | In parallel GC, the amount of balanced data copied by all threads
[gcdetails_par_balanced_copied_bytes] :: GCDetails -> Word64

-- | The amount of memory lost due to block fragmentation in bytes. Block
--   fragmentation is the difference between the amount of blocks retained
--   by the RTS and the blocks that are in use. This occurs when megablocks
--   are only sparsely used, eg, when data that cannot be moved retains a
--   megablock.
[gcdetails_block_fragmentation_bytes] :: GCDetails -> Word64

-- | The time elapsed during synchronisation before GC
[gcdetails_sync_elapsed_ns] :: GCDetails -> RtsTime

-- | The CPU time used during GC itself
[gcdetails_cpu_ns] :: GCDetails -> RtsTime

-- | The time elapsed during GC itself
[gcdetails_elapsed_ns] :: GCDetails -> RtsTime

-- | The CPU time used during the post-mark pause phase of the concurrent
--   nonmoving GC.
[gcdetails_nonmoving_gc_sync_cpu_ns] :: GCDetails -> RtsTime

-- | The time elapsed during the post-mark pause phase of the concurrent
--   nonmoving GC.
[gcdetails_nonmoving_gc_sync_elapsed_ns] :: GCDetails -> RtsTime

-- | Time values from the RTS, using a fixed resolution of nanoseconds.
type RtsTime = Int64

-- | Get current runtime system statistics.
getRTSStats :: IO RTSStats

-- | Returns whether GC stats have been enabled (with <tt>+RTS -T</tt>, for
--   example).
getRTSStatsEnabled :: IO Bool

module GHC.TypeLits.Experimental
appendSSymbol :: forall (a :: Symbol) (b :: Symbol). SSymbol a -> SSymbol b -> SSymbol (AppendSymbol a b)
consSSymbol :: forall (a :: Char) (b :: Symbol). SChar a -> SSymbol b -> SSymbol (ConsSymbol a b)
sCharToSNat :: forall (a :: Char). SChar a -> SNat (CharToNat a)
sNatToSChar :: forall (n :: Natural). n <= 1114111 => SNat n -> SChar (NatToChar n)

module GHC.TypeNats.Experimental
plusSNat :: forall (n :: Nat) (m :: Nat). SNat n -> SNat m -> SNat (n + m)
timesSNat :: forall (n :: Nat) (m :: Nat). SNat n -> SNat m -> SNat (n * m)
powerSNat :: forall (n :: Nat) (m :: Nat). SNat n -> SNat m -> SNat (n ^ m)
minusSNat :: forall (m :: Nat) (n :: Nat). m <= n => SNat n -> SNat m -> SNat (n - m)
divSNat :: forall (m :: Natural) (n :: Nat). 1 <= m => SNat n -> SNat m -> SNat (Div n m)
modSNat :: forall (m :: Natural) (n :: Nat). 1 <= m => SNat n -> SNat m -> SNat (Mod n m)
log2SNat :: forall (n :: Natural). 1 <= n => SNat n -> SNat (Log2 n)

module Prelude.Experimental

-- | The builtin linked list type.
--   
--   In Haskell, lists are one of the most important data types as they are
--   often used analogous to loops in imperative programming languages.
--   These lists are singly linked, which makes them unsuited for
--   operations that require &lt;math&gt; access. Instead, they are
--   intended to be traversed.
--   
--   You can use <tt>List a</tt> or <tt>[a]</tt> in type signatures:
--   
--   <pre>
--   length :: [a] -&gt; Int
--   </pre>
--   
--   or
--   
--   <pre>
--   length :: List a -&gt; Int
--   </pre>
--   
--   They are fully equivalent, and <tt>List a</tt> will be normalised to
--   <tt>[a]</tt>.
--   
--   <h4>Usage</h4>
--   
--   Lists are constructed recursively using the right-associative
--   constructor operator (or <i>cons</i>) <tt>(:) :: a -&gt; [a] -&gt;
--   [a]</tt>, which prepends an element to a list, and the empty list
--   <tt>[]</tt>.
--   
--   <pre>
--   (1 : 2 : 3 : []) == (1 : (2 : (3 : []))) == [1, 2, 3]
--   </pre>
--   
--   Lists can also be constructed using list literals of the form
--   <tt>[x_1, x_2, ..., x_n]</tt> which are syntactic sugar and, unless
--   <tt>-XOverloadedLists</tt> is enabled, are translated into uses of
--   <tt>(:)</tt> and <tt>[]</tt>
--   
--   <a>String</a> literals, like <tt>"I 💜 hs"</tt>, are translated into
--   Lists of characters, <tt>['I', ' ', '💜', ' ', 'h', 's']</tt>.
--   
--   <h4><b>Implementation</b></h4>
--   
--   Internally and in memory, all the above are represented like this,
--   with arrows being pointers to locations in memory.
--   
--   <pre>
--   ╭───┬───┬──╮   ╭───┬───┬──╮   ╭───┬───┬──╮   ╭────╮
--   │(:)│   │ ─┼──&gt;│(:)│   │ ─┼──&gt;│(:)│   │ ─┼──&gt;│ [] │
--   ╰───┴─┼─┴──╯   ╰───┴─┼─┴──╯   ╰───┴─┼─┴──╯   ╰────╯
--         v              v              v
--         1              2              3
--   </pre>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ['H', 'a', 's', 'k', 'e', 'l', 'l']
--   "Haskell"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 1 : [4, 1, 5, 9]
--   [1,4,1,5,9]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; [] : [] : []
--   [[],[]]
--   </pre>
data [] a

module System.Mem.Experimental

-- | Define the behaviour for handling allocation limits. The default
--   behaviour is to throw an <tt>AllocationLimitExceeded</tt> async
--   exception to the thread. This can be overriden using
--   <tt>AllocationLimitKillBehaviour</tt>.
--   
--   We can set a user-specified handler, which can be run in addition to
--   or in place of the exception. This allows for instance logging on the
--   allocation limit being exceeded, or dynamically determining whether to
--   terminate the thread. The handler is not guaranteed to run before the
--   thread is terminated or restarted.
--   
--   Note: that if you don't terminate the thread, then the allocation
--   limit gets removed. If you wish to keep the allocation limit you will
--   have to reset it using <tt>setAllocationCounter</tt> and
--   <tt>enableAllocationLimit</tt>.
setGlobalAllocationLimitHandler :: AllocationLimitKillBehaviour -> Maybe (ThreadId -> IO ()) -> IO ()
data AllocationLimitKillBehaviour

-- | Throw a <tt>AllocationLimitExceeded</tt> async exception to the thread
--   when the allocation limit is exceeded.
KillOnAllocationLimit :: AllocationLimitKillBehaviour

-- | Do not throw an exception when the allocation limit is exceeded.
DontKillOnAllocationLimit :: AllocationLimitKillBehaviour

-- | Get the allocation counter for a different thread.
--   
--   Note: this doesn't take the current nursery chunk into account. If the
--   thread is running then it may underestimate allocations by the size of
--   a nursery thread.
getAllocationCounterFor :: ThreadId -> IO Int64

-- | Set the allocation counter for a different thread. This can be
--   combined with <a>enableAllocationLimitFor</a> to enable allocation
--   limits for another thread. You may wish to do this during a
--   user-specified allocation limit handler.
--   
--   Note: this doesn't take the current nursery chunk into account. If the
--   thread is running then it may overestimate allocations by the size of
--   a nursery thread, and trigger the limit sooner than expected.
setAllocationCounterFor :: Int64 -> ThreadId -> IO ()

-- | Enable allocation limit processing the thread <tt>t</tt>.
enableAllocationLimitFor :: ThreadId -> IO ()

-- | Disable allocation limit processing the thread <tt>t</tt>.
disableAllocationLimitFor :: ThreadId -> IO ()
