    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE CPP #-}
    {-# LANGUAGE EmptyDataDecls #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeOperators #-}
    {-# LANGUAGE TypeSynonymInstances #-}

    #if __GLASGOW_HASKELL__ >= 711
    {-# LANGUAGE Safe #-}
    #elif __GLASGOW_HASKELL__ >= 701
    {-# LANGUAGE Trustworthy #-}
    #endif

    #if __GLASGOW_HASKELL__ >= 702
    {-# LANGUAGE DeriveGeneric #-}
    #endif

    #if __GLASGOW_HASKELL__ >= 705
    {-# LANGUAGE PolyKinds #-}
    #endif

    {-# OPTIONS_GHC -fno-warn-orphans #-}

    module Generics.Deriving.Instances (
    -- Only instances from Generics.Deriving.Base
    -- and the Generic1 instances
    #if !(MIN_VERSION_base(4,16,0))
        Rep0Tuple8
      , Rep0Tuple9
      , Rep0Tuple10
      , Rep0Tuple11
      , Rep0Tuple12
      , Rep0Tuple13
      , Rep0Tuple14
      , Rep0Tuple15
      , Rep1Tuple8
      , Rep1Tuple9
      , Rep1Tuple10
      , Rep1Tuple11
      , Rep1Tuple12
      , Rep1Tuple13
      , Rep1Tuple14
      , Rep1Tuple15
    #endif
    #if !(MIN_VERSION_base(4,14,0))
      , Rep0Kleisli
      , Rep1Kleisli
    #endif
    #if !(MIN_VERSION_base(4,12,0))
      , Rep0Down
      , Rep1Down
    #endif
    #if !(MIN_VERSION_base(4,9,0))
      , Rep0ExitCode
      , Rep0Version
      , Rep1ConSum
      , Rep1ConProduct
      , Rep1ConCompose
      , Rep1K1
      , Rep1M1
      , Rep1Par1
      , Rep1Rec1
      , Rep1U1
      , Rep0V1
      , Rep1V1
      , Rep0UAddr
      , Rep1UAddr
      , Rep0UChar
      , Rep1UChar
      , Rep0UDouble
      , Rep1UDouble
      , Rep0UFloat
      , Rep1UFloat
      , Rep0UInt
      , Rep1UInt
      , Rep0UWord
      , Rep1UWord
    # if MIN_VERSION_base(4,4,0)
      , Rep0Complex
      , Rep1Complex
    # endif
    # if MIN_VERSION_base(4,7,0)
      , Rep1Proxy
    # endif
    #endif
    #if !(MIN_VERSION_base(4,7,0))
      , Rep0All
      , Rep0Any
      , Rep0Arity
      , Rep0Associativity
      , Rep0Const
      , Rep1Const
      , Rep0Dual
      , Rep1Dual
      , Rep0Endo
      , Rep0First
      , Rep1First
      , Rep0Fixity
      , Rep0Last
      , Rep1Last
      , Rep0Product
      , Rep1Product
      , Rep0Sum
      , Rep1Sum
      , Rep0WrappedArrow
      , Rep1WrappedArrow
      , Rep0WrappedMonad
      , Rep1WrappedMonad
      , Rep0ZipList
      , Rep1ZipList
      , Rep0U1
      , Rep0Par1
      , Rep0Rec1
      , Rep0K1
      , Rep0M1
      , Rep0ConSum
      , Rep0ConProduct
      , Rep0ConCompose
    #endif
    #if !(MIN_VERSION_base(4,6,0))
      , Rep1Either
      , Rep1List
      , Rep1Maybe
      , Rep1Tuple2
      , Rep1Tuple3
      , Rep1Tuple4
      , Rep1Tuple5
      , Rep1Tuple6
      , Rep1Tuple7
    #endif
    #if !(MIN_VERSION_base(4,4,0))
      , Rep0Bool
      , Rep0Char
      , Rep0Double
      , Rep0Either
      , Rep0Int
      , Rep0Float
      , Rep0List
      , Rep0Maybe
      , Rep0Ordering
      , Rep0Tuple2
      , Rep0Tuple3
      , Rep0Tuple4
      , Rep0Tuple5
      , Rep0Tuple6
      , Rep0Tuple7
      , Rep0Unit
    #endif
      ) where

    #if !(MIN_VERSION_base(4,7,0))
    import Control.Applicative
    import Data.Monoid
    #endif

    #if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0))
    import Data.Complex (Complex(..))
    #endif

    #if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,9,0))
    import Data.Proxy (Proxy(..))
    #endif

    #if !(MIN_VERSION_base(4,9,0))
    import Data.Version (Version(..))
    import System.Exit (ExitCode(..))
    #endif

    #if !(MIN_VERSION_base(4,12,0))
    # if MIN_VERSION_base(4,6,0)
    import Data.Ord (Down(..))
    # else
    import GHC.Exts (Down(..))
    # endif
    #endif

    #if !(MIN_VERSION_base(4,14,0))
    import Control.Arrow (Kleisli(..))
    #endif

    #if !(MIN_VERSION_base(4,16,0))
    import Generics.Deriving.Base.Internal
    #endif

    #if !(MIN_VERSION_base(4,16,0))
    # if MIN_VERSION_base(4,6,0)
    type Rep0Tuple8  a b c d e f g h               = Rep (a, b, c, d, e, f, g, h)
    type Rep0Tuple9  a b c d e f g h i             = Rep (a, b, c, d, e, f, g, h, i)
    type Rep0Tuple10 a b c d e f g h i j           = Rep (a, b, c, d, e, f, g, h, i, j)
    type Rep0Tuple11 a b c d e f g h i j k         = Rep (a, b, c, d, e, f, g, h, i, j, k)
    type Rep0Tuple12 a b c d e f g h i j k l       = Rep (a, b, c, d, e, f, g, h, i, j, k, l)
    type Rep0Tuple13 a b c d e f g h i j k l m     = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m)
    type Rep0Tuple14 a b c d e f g h i j k l m n   = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    type Rep0Tuple15 a b c d e f g h i j k l m n o = Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    type Rep1Tuple8  a b c d e f g               = Rep1 ((,,,,,,,) a b c d e f g)
    type Rep1Tuple9  a b c d e f g h             = Rep1 ((,,,,,,,,) a b c d e f g h)
    type Rep1Tuple10 a b c d e f g h i           = Rep1 ((,,,,,,,,,) a b c d e f g h i)
    type Rep1Tuple11 a b c d e f g h i j         = Rep1 ((,,,,,,,,,,) a b c d e f g h i j)
    type Rep1Tuple12 a b c d e f g h i j k       = Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k)
    type Rep1Tuple13 a b c d e f g h i j k l     = Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)
    type Rep1Tuple14 a b c d e f g h i j k l m   = Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)
    type Rep1Tuple15 a b c d e f g h i j k l m n = Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)
    deriving instance Generic (a, b, c, d, e, f, g, h)
    deriving instance Generic (a, b, c, d, e, f, g, h, i)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    deriving instance Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    deriving instance Generic1 ((,,,,,,,) a b c d e f g)
    deriving instance Generic1 ((,,,,,,,,) a b c d e f g h)
    deriving instance Generic1 ((,,,,,,,,,) a b c d e f g h i)
    deriving instance Generic1 ((,,,,,,,,,,) a b c d e f g h i j)
    deriving instance Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k)
    deriving instance Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)
    deriving instance Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)
    deriving instance Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)
    # else
    type Rep0Tuple8 a b c d e f g h = D1
                                        D1Tuple8
                                        (C1
                                           C1_0Tuple8
                                           (((S1
                                                NoSelector
                                                (Rec0 a)
                                              :*: S1
                                                                 NoSelector
                                                                 (Rec0
                                                                    b))
                                             :*: (S1
                                                                 NoSelector
                                                                 (Rec0
                                                                    c)
                                                               :*: S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     d)))
                                            :*: ((S1
                                                                 NoSelector
                                                                 (Rec0
                                                                    e)
                                                               :*: S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     f))
                                                              :*: (S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     g)
                                                                                :*: S1
                                                                                                   NoSelector
                                                                                                   (Rec0
                                                                                                      h)))))
    type Rep1Tuple8 a b c d e f g = D1
                                      D1Tuple8
                                      (C1
                                         C1_0Tuple8
                                         (((S1
                                              NoSelector
                                              (Rec0 a)
                                            :*: S1
                                                               NoSelector
                                                               (Rec0
                                                                  b))
                                           :*: (S1
                                                               NoSelector
                                                               (Rec0
                                                                  c)
                                                             :*: S1
                                                                                NoSelector
                                                                                (Rec0
                                                                                   d)))
                                          :*: ((S1
                                                               NoSelector
                                                               (Rec0
                                                                  e)
                                                             :*: S1
                                                                                NoSelector
                                                                                (Rec0
                                                                                   f))
                                                            :*: (S1
                                                                                NoSelector
                                                                                (Rec0
                                                                                   g)
                                                                              :*: S1
                                                                                                 NoSelector
                                                                                                 Par1))))

    instance Generic (a, b, c, d, e, f, g, h) where
        type Rep (a, b, c, d, e, f, g, h) = Rep0Tuple8 a b c d e f g h

        from x
          = M1
              (case x of {
                 (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 (M1 (K1 g4))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g5))
                                 (M1 (K1 g6)))
                              ((:*:)
                                 (M1 (K1 g7))
                                 (M1 (K1 g8))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           (M1 (K1 g2)))
                                                                       ((:*:) (M1 (K1 g3))
                                                                                           (M1 (K1 g4))))
                                                   ((:*:) ((:*:) (M1 (K1 g5))
                                                                                           (M1 (K1 g6)))
                                                                       ((:*:) (M1 (K1 g7))
                                                                                           (M1 (K1 g8))))))
                -> (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 }

    instance Generic1 ((,,,,,,,) a b c d e f g) where
        type Rep1 ((,,,,,,,) a b c d e f g) = Rep1Tuple8 a b c d e f g

        from1 x
          = M1
              (case x of {
                 (,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 (M1 (K1 g4))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g5))
                                 (M1 (K1 g6)))
                              ((:*:)
                                 (M1 (K1 g7))
                                 (M1 (Par1 g8))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           (M1 g2))
                                                                       ((:*:) (M1 g3)
                                                                                           (M1 g4)))
                                                   ((:*:) ((:*:) (M1 g5)
                                                                                           (M1 g6))
                                                                       ((:*:) (M1 g7)
                                                                                           (M1 g8)))))
                -> (,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unPar1 g8) }

    data D1Tuple8
    data C1_0Tuple8

    instance Datatype D1Tuple8 where
        datatypeName _ = "(,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple8 where
        conName _ = "(,,,,,,,)"

    -----

    type Rep0Tuple9 a b c d e f g h i = D1
                                          D1Tuple9
                                          (C1
                                             C1_0Tuple9
                                             (((S1
                                                  NoSelector
                                                  (Rec0 a)
                                                :*: S1
                                                                   NoSelector
                                                                   (Rec0
                                                                      b))
                                               :*: (S1
                                                                   NoSelector
                                                                   (Rec0
                                                                      c)
                                                                 :*: S1
                                                                                    NoSelector
                                                                                    (Rec0
                                                                                       d)))
                                              :*: ((S1
                                                                   NoSelector
                                                                   (Rec0
                                                                      e)
                                                                 :*: S1
                                                                                    NoSelector
                                                                                    (Rec0
                                                                                       f))
                                                                :*: (S1
                                                                                    NoSelector
                                                                                    (Rec0
                                                                                       g)
                                                                                  :*: (S1
                                                                                                      NoSelector
                                                                                                      (Rec0
                                                                                                         h)
                                                                                                    :*: S1
                                                                                                                       NoSelector
                                                                                                                       (Rec0
                                                                                                                          i))))))
    type Rep1Tuple9 a b c d e f g h = D1
                                        D1Tuple9
                                        (C1
                                           C1_0Tuple9
                                           (((S1
                                                NoSelector (Rec0 a)
                                              :*: S1
                                                                 NoSelector
                                                                 (Rec0 b))
                                             :*: (S1
                                                                 NoSelector
                                                                 (Rec0 c)
                                                               :*: S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     d)))
                                            :*: ((S1
                                                                 NoSelector
                                                                 (Rec0 e)
                                                               :*: S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     f))
                                                              :*: (S1
                                                                                  NoSelector
                                                                                  (Rec0
                                                                                     g)
                                                                                :*: (S1
                                                                                                    NoSelector
                                                                                                    (Rec0
                                                                                                       h)
                                                                                                  :*: S1
                                                                                                                     NoSelector
                                                                                                                     Par1)))))

    instance Generic (a, b, c, d, e, f, g, h, i) where
        type Rep (a, b, c, d, e, f, g, h, i) = Rep0Tuple9 a b c d e f g h i

        from x
          = M1
              (case x of {
                 (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 (M1 (K1 g4))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g5))
                                 (M1 (K1 g6)))
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           (M1 (K1 g2)))
                                                                       ((:*:) (M1 (K1 g3))
                                                                                           (M1 (K1 g4))))
                                                   ((:*:) ((:*:) (M1 (K1 g5))
                                                                                           (M1 (K1 g6)))
                                                                       ((:*:) (M1 (K1 g7))
                                                                                           ((:*:) (M1 (K1 g8))
                                                                                                               (M1 (K1 g9)))))))
                -> (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 }

    instance Generic1 ((,,,,,,,,) a b c d e f g h) where
        type Rep1 ((,,,,,,,,) a b c d e f g h) = Rep1Tuple9 a b c d e f g h

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 (M1 (K1 g4))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g5))
                                 (M1 (K1 g6)))
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (Par1 g9)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           (M1 g2))
                                                                       ((:*:) (M1 g3)
                                                                                           (M1 g4)))
                                                   ((:*:) ((:*:) (M1 g5)
                                                                                           (M1 g6))
                                                                       ((:*:) (M1 g7)
                                                                                           ((:*:) (M1 g8)
                                                                                                               (M1 g9))))))
                -> (,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unPar1 g9) }

    data D1Tuple9
    data C1_0Tuple9

    instance Datatype D1Tuple9 where
        datatypeName _ = "(,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple9 where
        conName _ = "(,,,,,,,,)"

    -----

    type Rep0Tuple10 a b c d e f g h i j = D1
                                             D1Tuple10
                                             (C1
                                                C1_0Tuple10
                                                (((S1
                                                     NoSelector (Rec0 a)
                                                   :*: S1
                                                                      NoSelector
                                                                      (Rec0 b))
                                                  :*: (S1
                                                                      NoSelector
                                                                      (Rec0 c)
                                                                    :*: (S1
                                                                                        NoSelector
                                                                                        (Rec0
                                                                                           d)
                                                                                      :*: S1
                                                                                                         NoSelector
                                                                                                         (Rec0
                                                                                                            e))))
                                                 :*: ((S1
                                                                      NoSelector
                                                                      (Rec0 f)
                                                                    :*: S1
                                                                                       NoSelector
                                                                                       (Rec0
                                                                                          g))
                                                                   :*: (S1
                                                                                       NoSelector
                                                                                       (Rec0
                                                                                          h)
                                                                                     :*: (S1
                                                                                                         NoSelector
                                                                                                         (Rec0
                                                                                                            i)
                                                                                                       :*: S1
                                                                                                                          NoSelector
                                                                                                                          (Rec0
                                                                                                                             j))))))
    type Rep1Tuple10 a b c d e f g h i = D1
                                           D1Tuple10
                                           (C1
                                              C1_0Tuple10
                                              (((S1
                                                   NoSelector (Rec0 a)
                                                 :*: S1
                                                                    NoSelector
                                                                    (Rec0 b))
                                                :*: (S1
                                                                    NoSelector
                                                                    (Rec0 c)
                                                                  :*: (S1
                                                                                      NoSelector
                                                                                      (Rec0
                                                                                         d)
                                                                                    :*: S1
                                                                                                       NoSelector
                                                                                                       (Rec0
                                                                                                          e))))
                                               :*: ((S1
                                                                    NoSelector
                                                                    (Rec0 f)
                                                                  :*: S1
                                                                                     NoSelector
                                                                                     (Rec0
                                                                                        g))
                                                                 :*: (S1
                                                                                     NoSelector
                                                                                     (Rec0
                                                                                        h)
                                                                                   :*: (S1
                                                                                                       NoSelector
                                                                                                       (Rec0
                                                                                                          i)
                                                                                                     :*: S1
                                                                                                                        NoSelector
                                                                                                                        Par1)))))

    instance Generic (a, b, c, d, e, f, g, h, i, j) where
        type Rep (a, b, c, d, e, f, g, h, i, j) = Rep0Tuple10 a b c d e f g h i j

        from x
          = M1
              (case x of {
                 (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g6))
                                 (M1 (K1 g7)))
                              ((:*:)
                                 (M1 (K1 g8))
                                 ((:*:)
                                    (M1 (K1 g9))
                                    (M1 (K1 g10)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           (M1 (K1 g2)))
                                                                       ((:*:) (M1 (K1 g3))
                                                                                           ((:*:) (M1 (K1 g4))
                                                                                                               (M1 (K1 g5)))))
                                                   ((:*:) ((:*:) (M1 (K1 g6))
                                                                                           (M1 (K1 g7)))
                                                                       ((:*:) (M1 (K1 g8))
                                                                                           ((:*:) (M1 (K1 g9))
                                                                                                               (M1 (K1 g10)))))))
                -> (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 }

    instance Generic1
                 ((,,,,,,,,,) a b c d e f g h i) where
        type Rep1 ((,,,,,,,,,) a b c d e f g h i) = Rep1Tuple10 a b c d e f g h i

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g6))
                                 (M1 (K1 g7)))
                              ((:*:)
                                 (M1 (K1 g8))
                                 ((:*:)
                                    (M1 (K1 g9))
                                    (M1 (Par1 g10)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           (M1 g2))
                                                                       ((:*:) (M1 g3)
                                                                                           ((:*:) (M1 g4)
                                                                                                               (M1 g5))))
                                                   ((:*:) ((:*:) (M1 g6)
                                                                                           (M1 g7))
                                                                       ((:*:) (M1 g8)
                                                                                           ((:*:) (M1 g9)
                                                                                                               (M1 g10))))))
                -> (,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unPar1 g10) }

    data D1Tuple10
    data C1_0Tuple10

    instance Datatype D1Tuple10 where
        datatypeName _ = "(,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple10 where
        conName _ = "(,,,,,,,,,)"

    -----

    type Rep0Tuple11 a b c d e f g h i j k = D1
                                               D1Tuple11
                                               (C1
                                                  C1_0Tuple11
                                                  (((S1
                                                       NoSelector
                                                       (Rec0 a)
                                                     :*: S1
                                                                        NoSelector
                                                                        (Rec0 b))
                                                    :*: (S1
                                                                        NoSelector
                                                                        (Rec0 c)
                                                                      :*: (S1
                                                                                          NoSelector
                                                                                          (Rec0
                                                                                             d)
                                                                                        :*: S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              e))))
                                                   :*: ((S1
                                                                        NoSelector
                                                                        (Rec0 f)
                                                                      :*: (S1
                                                                                          NoSelector
                                                                                          (Rec0
                                                                                             g)
                                                                                        :*: S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              h)))
                                                                     :*: (S1
                                                                                         NoSelector
                                                                                         (Rec0
                                                                                            i)
                                                                                       :*: (S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              j)
                                                                                                         :*: S1
                                                                                                                            NoSelector
                                                                                                                            (Rec0
                                                                                                                               k))))))
    type Rep1Tuple11 a b c d e f g h i j = D1
                                             D1Tuple11
                                             (C1
                                                C1_0Tuple11
                                                (((S1
                                                     NoSelector
                                                     (Rec0 a)
                                                   :*: S1
                                                                      NoSelector
                                                                      (Rec0 b))
                                                  :*: (S1
                                                                      NoSelector
                                                                      (Rec0 c)
                                                                    :*: (S1
                                                                                        NoSelector
                                                                                        (Rec0
                                                                                           d)
                                                                                      :*: S1
                                                                                                         NoSelector
                                                                                                         (Rec0
                                                                                                            e))))
                                                 :*: ((S1
                                                                      NoSelector
                                                                      (Rec0 f)
                                                                    :*: (S1
                                                                                        NoSelector
                                                                                        (Rec0
                                                                                           g)
                                                                                      :*: S1
                                                                                                         NoSelector
                                                                                                         (Rec0
                                                                                                            h)))
                                                                   :*: (S1
                                                                                       NoSelector
                                                                                       (Rec0
                                                                                          i)
                                                                                     :*: (S1
                                                                                                         NoSelector
                                                                                                         (Rec0
                                                                                                            j)
                                                                                                       :*: S1
                                                                                                                          NoSelector
                                                                                                                          Par1)))))

    instance Generic
                 (a, b, c, d, e, f, g, h, i, j, k) where
        type Rep (a, b, c, d, e, f, g, h, i, j, k) = Rep0Tuple11 a b c d e f g h i j k

        from x
          = M1
              (case x of {
                 (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g6))
                                 ((:*:)
                                    (M1 (K1 g7))
                                    (M1 (K1 g8))))
                              ((:*:)
                                 (M1 (K1 g9))
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (K1 g11)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           (M1 (K1 g2)))
                                                                       ((:*:) (M1 (K1 g3))
                                                                                           ((:*:) (M1 (K1 g4))
                                                                                                               (M1 (K1 g5)))))
                                                   ((:*:) ((:*:) (M1 (K1 g6))
                                                                                           ((:*:) (M1 (K1 g7))
                                                                                                               (M1 (K1 g8))))
                                                                       ((:*:) (M1 (K1 g9))
                                                                                           ((:*:) (M1 (K1 g10))
                                                                                                               (M1 (K1 g11)))))))
                -> (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 }

    instance Generic1
                 ((,,,,,,,,,,) a b c d e f g h i j) where
        type Rep1 ((,,,,,,,,,,) a b c d e f g h i j) = Rep1Tuple11 a b c d e f g h i j

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 (M1 (K1 g2)))
                              ((:*:)
                                 (M1 (K1 g3))
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g6))
                                 ((:*:)
                                    (M1 (K1 g7))
                                    (M1 (K1 g8))))
                              ((:*:)
                                 (M1 (K1 g9))
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (Par1 g11)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           (M1 g2))
                                                                       ((:*:) (M1 g3)
                                                                                           ((:*:) (M1 g4)
                                                                                                               (M1 g5))))
                                                   ((:*:) ((:*:) (M1 g6)
                                                                                           ((:*:) (M1 g7)
                                                                                                               (M1 g8)))
                                                                       ((:*:) (M1 g9)
                                                                                           ((:*:) (M1 g10)
                                                                                                               (M1 g11))))))
                -> (,,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unK1 g10)
                     (unPar1 g11) }

    data D1Tuple11
    data C1_0Tuple11

    instance Datatype D1Tuple11 where
        datatypeName _ = "(,,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple11 where
        conName _ = "(,,,,,,,,,,)"

    -----

    type Rep0Tuple12 a b c d e f g h i j k l = D1
                                                 D1Tuple12
                                                 (C1
                                                    C1_0Tuple12
                                                    (((S1
                                                         NoSelector
                                                         (Rec0 a)
                                                       :*: (S1
                                                                           NoSelector
                                                                           (Rec0 b)
                                                                         :*: S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               c)))
                                                      :*: (S1
                                                                          NoSelector
                                                                          (Rec0 d)
                                                                        :*: (S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               e)
                                                                                          :*: S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                f))))
                                                     :*: ((S1
                                                                          NoSelector
                                                                          (Rec0 g)
                                                                        :*: (S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               h)
                                                                                          :*: S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                i)))
                                                                       :*: (S1
                                                                                           NoSelector
                                                                                           (Rec0
                                                                                              j)
                                                                                         :*: (S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                k)
                                                                                                           :*: S1
                                                                                                                              NoSelector
                                                                                                                              (Rec0
                                                                                                                                 l))))))
    type Rep1Tuple12 a b c d e f g h i j k = D1
                                               D1Tuple12
                                               (C1
                                                  C1_0Tuple12
                                                  (((S1
                                                       NoSelector
                                                       (Rec0 a)
                                                     :*: (S1
                                                                         NoSelector
                                                                         (Rec0 b)
                                                                       :*: S1
                                                                                          NoSelector
                                                                                          (Rec0
                                                                                             c)))
                                                    :*: (S1
                                                                        NoSelector
                                                                        (Rec0 d)
                                                                      :*: (S1
                                                                                          NoSelector
                                                                                          (Rec0
                                                                                             e)
                                                                                        :*: S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              f))))
                                                   :*: ((S1
                                                                        NoSelector
                                                                        (Rec0 g)
                                                                      :*: (S1
                                                                                          NoSelector
                                                                                          (Rec0
                                                                                             h)
                                                                                        :*: S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              i)))
                                                                     :*: (S1
                                                                                         NoSelector
                                                                                         (Rec0
                                                                                            j)
                                                                                       :*: (S1
                                                                                                           NoSelector
                                                                                                           (Rec0
                                                                                                              k)
                                                                                                         :*: S1
                                                                                                                            NoSelector
                                                                                                                            Par1)))))

    instance Generic
                 (a, b, c, d, e, f, g, h, i, j, k, l) where
        type Rep (a, b, c, d, e, f, g, h, i, j, k, l) = Rep0Tuple12 a b c d e f g h i j k l

        from x
          = M1
              (case x of {
                 (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 (M1 (K1 g4))
                                 ((:*:)
                                    (M1 (K1 g5))
                                    (M1 (K1 g6)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9))))
                              ((:*:)
                                 (M1 (K1 g10))
                                 ((:*:)
                                    (M1 (K1 g11))
                                    (M1 (K1 g12)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           ((:*:) (M1 (K1 g2))
                                                                                                               (M1 (K1 g3))))
                                                                       ((:*:) (M1 (K1 g4))
                                                                                           ((:*:) (M1 (K1 g5))
                                                                                                               (M1 (K1 g6)))))
                                                   ((:*:) ((:*:) (M1 (K1 g7))
                                                                                           ((:*:) (M1 (K1 g8))
                                                                                                               (M1 (K1 g9))))
                                                                       ((:*:) (M1 (K1 g10))
                                                                                           ((:*:) (M1 (K1 g11))
                                                                                                               (M1 (K1 g12)))))))
                -> (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 }

    instance Generic1
                 ((,,,,,,,,,,,) a b c d e f g h i j k) where
        type Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) = Rep1Tuple12 a b c d e f g h i j k

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 (M1 (K1 g4))
                                 ((:*:)
                                    (M1 (K1 g5))
                                    (M1 (K1 g6)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9))))
                              ((:*:)
                                 (M1 (K1 g10))
                                 ((:*:)
                                    (M1 (K1 g11))
                                    (M1 (Par1 g12)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           ((:*:) (M1 g2)
                                                                                                               (M1 g3)))
                                                                       ((:*:) (M1 g4)
                                                                                           ((:*:) (M1 g5)
                                                                                                               (M1 g6))))
                                                   ((:*:) ((:*:) (M1 g7)
                                                                                           ((:*:) (M1 g8)
                                                                                                               (M1 g9)))
                                                                       ((:*:) (M1 g10)
                                                                                           ((:*:) (M1 g11)
                                                                                                               (M1 g12))))))
                -> (,,,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unK1 g10)
                     (unK1 g11) (unPar1 g12) }

    data D1Tuple12
    data C1_0Tuple12

    instance Datatype D1Tuple12 where
        datatypeName _ = "(,,,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple12 where
        conName _ = "(,,,,,,,,,,,)"

    -----

    type Rep0Tuple13 a b c d e f g h i j k l m = D1
                                                   D1Tuple13
                                                   (C1
                                                      C1_0Tuple13
                                                      (((S1
                                                           NoSelector
                                                           (Rec0 a)
                                                         :*: (S1
                                                                             NoSelector
                                                                             (Rec0
                                                                                b)
                                                                           :*: S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 c)))
                                                        :*: (S1
                                                                            NoSelector
                                                                            (Rec0
                                                                               d)
                                                                          :*: (S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 e)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  f))))
                                                       :*: ((S1
                                                                            NoSelector
                                                                            (Rec0
                                                                               g)
                                                                          :*: (S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 h)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  i)))
                                                                         :*: ((S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 j)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  k))
                                                                                           :*: (S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  l)
                                                                                                             :*: S1
                                                                                                                                NoSelector
                                                                                                                                (Rec0
                                                                                                                                   m))))))
    type Rep1Tuple13 a b c d e f g h i j k l = D1
                                                 D1Tuple13
                                                 (C1
                                                    C1_0Tuple13
                                                    (((S1
                                                         NoSelector
                                                         (Rec0 a)
                                                       :*: (S1
                                                                           NoSelector
                                                                           (Rec0
                                                                              b)
                                                                         :*: S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               c)))
                                                      :*: (S1
                                                                          NoSelector
                                                                          (Rec0
                                                                             d)
                                                                        :*: (S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               e)
                                                                                          :*: S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                f))))
                                                     :*: ((S1
                                                                          NoSelector
                                                                          (Rec0
                                                                             g)
                                                                        :*: (S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               h)
                                                                                          :*: S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                i)))
                                                                       :*: ((S1
                                                                                            NoSelector
                                                                                            (Rec0
                                                                                               j)
                                                                                          :*: S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                k))
                                                                                         :*: (S1
                                                                                                             NoSelector
                                                                                                             (Rec0
                                                                                                                l)
                                                                                                           :*: S1
                                                                                                                              NoSelector
                                                                                                                              Par1)))))

    data D1Tuple13
    data C1_0Tuple13

    instance Generic
                 (a, b, c, d, e, f, g, h, i, j, k, l, m) where
        type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) = Rep0Tuple13 a b c d e f g h i j k l m

        from x
          = M1
              (case x of {
                 (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 (M1 (K1 g4))
                                 ((:*:)
                                    (M1 (K1 g5))
                                    (M1 (K1 g6)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (K1 g11)))
                                 ((:*:)
                                    (M1 (K1 g12))
                                    (M1 (K1 g13)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           ((:*:) (M1 (K1 g2))
                                                                                                               (M1 (K1 g3))))
                                                                       ((:*:) (M1 (K1 g4))
                                                                                           ((:*:) (M1 (K1 g5))
                                                                                                               (M1 (K1 g6)))))
                                                   ((:*:) ((:*:) (M1 (K1 g7))
                                                                                           ((:*:) (M1 (K1 g8))
                                                                                                               (M1 (K1 g9))))
                                                                       ((:*:) ((:*:) (M1 (K1 g10))
                                                                                                               (M1 (K1 g11)))
                                                                                           ((:*:) (M1 (K1 g12))
                                                                                                               (M1 (K1 g13)))))))
                -> (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 }

    instance Generic1
                 ((,,,,,,,,,,,,) a b c d e f g h i j k l) where
        type Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) = Rep1Tuple13 a b c d e f g h i j k l

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 (M1 (K1 g4))
                                 ((:*:)
                                    (M1 (K1 g5))
                                    (M1 (K1 g6)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g7))
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (K1 g11)))
                                 ((:*:)
                                    (M1 (K1 g12))
                                    (M1 (Par1 g13)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           ((:*:) (M1 g2)
                                                                                                               (M1 g3)))
                                                                       ((:*:) (M1 g4)
                                                                                           ((:*:) (M1 g5)
                                                                                                               (M1 g6))))
                                                   ((:*:) ((:*:) (M1 g7)
                                                                                           ((:*:) (M1 g8)
                                                                                                               (M1 g9)))
                                                                       ((:*:) ((:*:) (M1 g10)
                                                                                                               (M1 g11))
                                                                                           ((:*:) (M1 g12)
                                                                                                               (M1 g13))))))
                -> (,,,,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unK1 g10)
                     (unK1 g11) (unK1 g12)
                     (unPar1 g13) }

    instance Datatype D1Tuple13 where
        datatypeName _ = "(,,,,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple13 where
        conName _ = "(,,,,,,,,,,,,)"

    -----

    type Rep0Tuple14 a b c d e f g h i j k l m n = D1
                                                     D1Tuple14
                                                     (C1
                                                        C1_0Tuple14
                                                        (((S1
                                                             NoSelector
                                                             (Rec0 a)
                                                           :*: (S1
                                                                               NoSelector
                                                                               (Rec0
                                                                                  b)
                                                                             :*: S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   c)))
                                                          :*: ((S1
                                                                               NoSelector
                                                                               (Rec0
                                                                                  d)
                                                                             :*: S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   e))
                                                                            :*: (S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   f)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    g))))
                                                         :*: ((S1
                                                                              NoSelector
                                                                              (Rec0
                                                                                 h)
                                                                            :*: (S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   i)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    j)))
                                                                           :*: ((S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   k)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    l))
                                                                                             :*: (S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    m)
                                                                                                               :*: S1
                                                                                                                                  NoSelector
                                                                                                                                  (Rec0
                                                                                                                                     n))))))
    type Rep1Tuple14 a b c d e f g h i j k l m = D1
                                                   D1Tuple14
                                                   (C1
                                                      C1_0Tuple14
                                                      (((S1
                                                           NoSelector
                                                           (Rec0 a)
                                                         :*: (S1
                                                                             NoSelector
                                                                             (Rec0
                                                                                b)
                                                                           :*: S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 c)))
                                                        :*: ((S1
                                                                             NoSelector
                                                                             (Rec0
                                                                                d)
                                                                           :*: S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 e))
                                                                          :*: (S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 f)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  g))))
                                                       :*: ((S1
                                                                            NoSelector
                                                                            (Rec0
                                                                               h)
                                                                          :*: (S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 i)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  j)))
                                                                         :*: ((S1
                                                                                              NoSelector
                                                                                              (Rec0
                                                                                                 k)
                                                                                            :*: S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  l))
                                                                                           :*: (S1
                                                                                                               NoSelector
                                                                                                               (Rec0
                                                                                                                  m)
                                                                                                             :*: S1
                                                                                                                                NoSelector
                                                                                                                                Par1)))))

    instance Generic
                 (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
        type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = Rep0Tuple14 a b c d e f g h i j k l m n

        from x
          = M1
              (case x of {
                 (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))
                                 ((:*:)
                                    (M1 (K1 g6))
                                    (M1 (K1 g7)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g8))
                                 ((:*:)
                                    (M1 (K1 g9))
                                    (M1 (K1 g10))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g11))
                                    (M1 (K1 g12)))
                                 ((:*:)
                                    (M1 (K1 g13))
                                    (M1 (K1 g14)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           ((:*:) (M1 (K1 g2))
                                                                                                               (M1 (K1 g3))))
                                                                       ((:*:) ((:*:) (M1 (K1 g4))
                                                                                                               (M1 (K1 g5)))
                                                                                           ((:*:) (M1 (K1 g6))
                                                                                                               (M1 (K1 g7)))))
                                                   ((:*:) ((:*:) (M1 (K1 g8))
                                                                                           ((:*:) (M1 (K1 g9))
                                                                                                               (M1 (K1 g10))))
                                                                       ((:*:) ((:*:) (M1 (K1 g11))
                                                                                                               (M1 (K1 g12)))
                                                                                           ((:*:) (M1 (K1 g13))
                                                                                                               (M1 (K1 g14)))))))
                -> (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 }

    instance Generic1
                 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) where
        type Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) = Rep1Tuple14 a b c d e f g h i j k l m

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))
                                 ((:*:)
                                    (M1 (K1 g6))
                                    (M1 (K1 g7)))))
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g8))
                                 ((:*:)
                                    (M1 (K1 g9))
                                    (M1 (K1 g10))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g11))
                                    (M1 (K1 g12)))
                                 ((:*:)
                                    (M1 (K1 g13))
                                    (M1 (Par1 g14)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           ((:*:) (M1 g2)
                                                                                                               (M1 g3)))
                                                                       ((:*:) ((:*:) (M1 g4)
                                                                                                               (M1 g5))
                                                                                           ((:*:) (M1 g6)
                                                                                                               (M1 g7))))
                                                   ((:*:) ((:*:) (M1 g8)
                                                                                           ((:*:) (M1 g9)
                                                                                                               (M1 g10)))
                                                                       ((:*:) ((:*:) (M1 g11)
                                                                                                               (M1 g12))
                                                                                           ((:*:) (M1 g13)
                                                                                                               (M1 g14))))))
                -> (,,,,,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unK1 g10)
                     (unK1 g11) (unK1 g12)
                     (unK1 g13) (unPar1 g14) }

    data D1Tuple14
    data C1_0Tuple14

    instance Datatype D1Tuple14 where
        datatypeName _ = "(,,,,,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple14 where
        conName _ = "(,,,,,,,,,,,,,)"

    -----

    type Rep0Tuple15 a b c d e f g h i j k l m n o = D1
                                                       D1Tuple15
                                                       (C1
                                                          C1_0Tuple15
                                                          (((S1
                                                               NoSelector
                                                               (Rec0 a)
                                                             :*: (S1
                                                                                 NoSelector
                                                                                 (Rec0
                                                                                    b)
                                                                               :*: S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     c)))
                                                            :*: ((S1
                                                                                 NoSelector
                                                                                 (Rec0
                                                                                    d)
                                                                               :*: S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     e))
                                                                              :*: (S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     f)
                                                                                                :*: S1
                                                                                                                   NoSelector
                                                                                                                   (Rec0
                                                                                                                      g))))
                                                           :*: (((S1
                                                                                 NoSelector
                                                                                 (Rec0
                                                                                    h)
                                                                               :*: S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     i))
                                                                              :*: (S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     j)
                                                                                                :*: S1
                                                                                                                   NoSelector
                                                                                                                   (Rec0
                                                                                                                      k)))
                                                                             :*: ((S1
                                                                                                  NoSelector
                                                                                                  (Rec0
                                                                                                     l)
                                                                                                :*: S1
                                                                                                                   NoSelector
                                                                                                                   (Rec0
                                                                                                                      m))
                                                                                               :*: (S1
                                                                                                                   NoSelector
                                                                                                                   (Rec0
                                                                                                                      n)
                                                                                                                 :*: S1
                                                                                                                                    NoSelector
                                                                                                                                    (Rec0
                                                                                                                                       o))))))
    type Rep1Tuple15 a b c d e f g h i j k l m n = D1
                                                     D1Tuple15
                                                     (C1
                                                        C1_0Tuple15
                                                        (((S1
                                                             NoSelector
                                                             (Rec0 a)
                                                           :*: (S1
                                                                               NoSelector
                                                                               (Rec0
                                                                                  b)
                                                                             :*: S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   c)))
                                                          :*: ((S1
                                                                               NoSelector
                                                                               (Rec0
                                                                                  d)
                                                                             :*: S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   e))
                                                                            :*: (S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   f)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    g))))
                                                         :*: (((S1
                                                                               NoSelector
                                                                               (Rec0
                                                                                  h)
                                                                             :*: S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   i))
                                                                            :*: (S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   j)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    k)))
                                                                           :*: ((S1
                                                                                                NoSelector
                                                                                                (Rec0
                                                                                                   l)
                                                                                              :*: S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    m))
                                                                                             :*: (S1
                                                                                                                 NoSelector
                                                                                                                 (Rec0
                                                                                                                    n)
                                                                                                               :*: S1
                                                                                                                                  NoSelector
                                                                                                                                  Par1)))))

    instance Generic
                 (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
        type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = Rep0Tuple15 a b c d e f g h i j k l m n o

        from x
          = M1
              (case x of {
                 (,,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))
                                 ((:*:)
                                    (M1 (K1 g6))
                                    (M1 (K1 g7)))))
                           ((:*:)
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9)))
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (K1 g11))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g12))
                                    (M1 (K1 g13)))
                                 ((:*:)
                                    (M1 (K1 g14))
                                    (M1 (K1 g15)))))) })
        to (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 (K1 g1))
                                                                                           ((:*:) (M1 (K1 g2))
                                                                                                               (M1 (K1 g3))))
                                                                       ((:*:) ((:*:) (M1 (K1 g4))
                                                                                                               (M1 (K1 g5)))
                                                                                           ((:*:) (M1 (K1 g6))
                                                                                                               (M1 (K1 g7)))))
                                                   ((:*:) ((:*:) ((:*:) (M1 (K1 g8))
                                                                                                               (M1 (K1 g9)))
                                                                                           ((:*:) (M1 (K1 g10))
                                                                                                               (M1 (K1 g11))))
                                                                       ((:*:) ((:*:) (M1 (K1 g12))
                                                                                                               (M1 (K1 g13)))
                                                                                           ((:*:) (M1 (K1 g14))
                                                                                                               (M1 (K1 g15)))))))
                -> (,,,,,,,,,,,,,,)
                     g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15 }

    instance Generic1
                 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) where
        type Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) = Rep1Tuple15 a b c d e f g h i j k l m n

        from1 x
          = M1
              (case x of {
                 (,,,,,,,,,,,,,,) g1 g2 g3 g4 g5 g6 g7 g8 g9 g10 g11 g12 g13 g14 g15
                   -> M1
                        ((:*:)
                           ((:*:)
                              ((:*:)
                                 (M1 (K1 g1))
                                 ((:*:)
                                    (M1 (K1 g2))
                                    (M1 (K1 g3))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g4))
                                    (M1 (K1 g5)))
                                 ((:*:)
                                    (M1 (K1 g6))
                                    (M1 (K1 g7)))))
                           ((:*:)
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g8))
                                    (M1 (K1 g9)))
                                 ((:*:)
                                    (M1 (K1 g10))
                                    (M1 (K1 g11))))
                              ((:*:)
                                 ((:*:)
                                    (M1 (K1 g12))
                                    (M1 (K1 g13)))
                                 ((:*:)
                                    (M1 (K1 g14))
                                    (M1 (Par1 g15)))))) })
        to1 (M1 x)
          = case x of {
              (M1 ((:*:) ((:*:) ((:*:) (M1 g1)
                                                                                           ((:*:) (M1 g2)
                                                                                                               (M1 g3)))
                                                                       ((:*:) ((:*:) (M1 g4)
                                                                                                               (M1 g5))
                                                                                           ((:*:) (M1 g6)
                                                                                                               (M1 g7))))
                                                   ((:*:) ((:*:) ((:*:) (M1 g8)
                                                                                                               (M1 g9))
                                                                                           ((:*:) (M1 g10)
                                                                                                               (M1 g11)))
                                                                       ((:*:) ((:*:) (M1 g12)
                                                                                                               (M1 g13))
                                                                                           ((:*:) (M1 g14)
                                                                                                               (M1 g15))))))
                -> (,,,,,,,,,,,,,,)
                     (unK1 g1) (unK1 g2)
                     (unK1 g3) (unK1 g4)
                     (unK1 g5) (unK1 g6)
                     (unK1 g7) (unK1 g8)
                     (unK1 g9) (unK1 g10)
                     (unK1 g11) (unK1 g12)
                     (unK1 g13) (unK1 g14)
                     (unPar1 g15) }

    data D1Tuple15
    data C1_0Tuple15

    instance Datatype D1Tuple15 where
        datatypeName _ = "(,,,,,,,,,,,,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple15 where
        conName _ = "(,,,,,,,,,,,,,,)"

    # endif
    #endif

    #if !(MIN_VERSION_base(4,14,0))
    # if MIN_VERSION_base(4,6,0)
    type Rep0Kleisli m a b = Rep  (Kleisli m a b)
    type Rep1Kleisli m a   = Rep1 (Kleisli m a)
    deriving instance Generic  (Kleisli m a b)
    deriving instance Generic1 (Kleisli m a)
    # else
    type Rep0Kleisli m a b = D1 D1Kleisli (C1 C1_0Kleisli (S1 S1_0_0Kleisli (Rec0 (a -> m b))))
    type Rep1Kleisli m a   = D1 D1Kleisli (C1 C1_0Kleisli (S1 S1_0_0Kleisli ((->) a :.: Rec1 m)))

    instance Generic (Kleisli m a b) where
        type Rep (Kleisli m a b) = Rep0Kleisli m a b
        from x = M1 (case x of
            Kleisli g -> M1 (M1 (K1 g)))
        to (M1 x) = case x of
            M1 (M1 (K1 g)) -> Kleisli g

    instance Generic1 (Kleisli m a) where
        type Rep1 (Kleisli m a) = Rep1Kleisli m a
        from1 x = M1 (case x of
            Kleisli g -> M1 (M1 (Comp1 (fmap Rec1 g))))
        to1 (M1 x) = case x of
            M1 (M1 g) -> Kleisli (fmap unRec1 (unComp1 g))

    data D1Kleisli
    data C1_0Kleisli
    data S1_0_0Kleisli

    instance Datatype D1Kleisli where
      datatypeName _ = "Kleisli"
      moduleName   _ = "Control.Arrow"

    instance Constructor C1_0Kleisli where
      conName     _ = "Kleisli"
      conIsRecord _ = True

    instance Selector S1_0_0Kleisli where
      selName _ = "runKleisli"
    # endif
    #endif

    #if !(MIN_VERSION_base(4,12,0))
    # if MIN_VERSION_base(4,6,0)
    type Rep0Down a = Rep (Down a)
    type Rep1Down   = Rep1 Down
    deriving instance Generic (Down a)
    deriving instance Generic1 Down
    # else
    type Rep0Down a = D1 D1Down (C1 C1_0Down (S1 NoSelector (Rec0 a)))
    type Rep1Down   = D1 D1Down (C1 C1_0Down (S1 NoSelector Par1))

    instance Generic (Down a) where
        type Rep (Down a) = Rep0Down a
        from x = M1 (case x of
            Down g -> M1 (M1 (K1 g)))
        to (M1 x) = case x of
            M1 (M1 (K1 g)) -> Down g

    instance Generic1 Down where
        type Rep1 Down = Rep1Down
        from1 x = M1 (case x of
            Down g -> M1 (M1 (Par1 g)))
        to1 (M1 x) = case x of
            M1 (M1 g) -> Down (unPar1 g)

    data D1Down
    data C1_0Down

    instance Datatype D1Down where
        datatypeName _ = "Down"
        moduleName   _ = "GHC.Exts"

    instance Constructor C1_0Down where
        conName _ = "Down"
    # endif
    #endif

    -----

    #if !(MIN_VERSION_base(4,9,0))
    type Rep0ExitCode = D1 D1ExitCode (C1 C1_0ExitCode U1
                                   :+: C1 C1_1ExitCode (S1 NoSelector (Rec0 Int)))

    instance Generic ExitCode where
        type Rep ExitCode = Rep0ExitCode
        from x = M1 (case x of
            ExitSuccess   -> L1 (M1 U1)
            ExitFailure g -> R1 (M1 (M1 (K1 g))))
        to (M1 x) = case x of
            L1 (M1 U1)          -> ExitSuccess
            R1 (M1 (M1 (K1 g))) -> ExitFailure g

    data D1ExitCode
    data C1_0ExitCode
    data C1_1ExitCode

    instance Datatype D1ExitCode where
        datatypeName _ = "ExitCode"
        moduleName   _ = "GHC.IO.Exception"

    instance Constructor C1_0ExitCode where
        conName _ = "ExitSuccess"

    instance Constructor C1_1ExitCode where
        conName _ = "ExitFailure"

    -----

    type Rep0Version = D1 D1Version (C1 C1_0Version (S1 S1_0_0Version (Rec0 [Int])
                                                 :*: S1 S1_0_1Version (Rec0 [String])))

    instance Generic Version where
        type Rep Version = Rep0Version
        from (Version b t) = M1 (M1 (M1 (K1 b) :*: M1 (K1 t)))
        to (M1 (M1 (M1 (K1 b) :*: M1 (K1 t)))) = Version b t

    data D1Version
    data C1_0Version
    data S1_0_0Version
    data S1_0_1Version

    instance Datatype D1Version where
        datatypeName _ = "Version"
        moduleName   _ = "Data.Version"

    instance Constructor C1_0Version where
        conName     _ = "Version"
        conIsRecord _ = True

    instance Selector S1_0_0Version where
        selName _ = "versionBranch"

    instance Selector S1_0_1Version where
        selName _ = "versionTags"

    -----

    type Rep1ConSum f g = D1 D1ConSum (C1 C1_0ConSum (S1 NoSelector (Rec1 f))
                                   :+: C1 C1_1ConSum (S1 NoSelector (Rec1 g)))

    instance Generic1 (f :+: g) where
        type Rep1 (f :+: g) = Rep1ConSum f g
        from1 x = M1 (case x of
            L1 l -> L1 (M1 (M1 (Rec1 l)))
            R1 r -> R1 (M1 (M1 (Rec1 r))))
        to1 (M1 x) = case x of
            L1 (M1 (M1 l)) -> L1 (unRec1 l)
            R1 (M1 (M1 r)) -> R1 (unRec1 r)

    data D1ConSum
    data C1_0ConSum
    data C1_1ConSum

    instance Datatype D1ConSum where
        datatypeName _ = ":+:"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0ConSum where
        conName _ = "L1"

    instance Constructor C1_1ConSum where
        conName _ = "R1"

    -----

    type Rep1ConProduct f g = D1 D1ConProduct (C1 C1_ConProduct (S1 NoSelector (Rec1 f)
                                                             :*: S1 NoSelector (Rec1 g)))

    instance Generic1 (f :*: g) where
        type Rep1 (f :*: g) = Rep1ConProduct f g
        from1 (f :*: g) = M1 (M1 (M1 (Rec1 f) :*: M1 (Rec1 g)))
        to1 (M1 (M1 (M1 f :*: M1 g))) = unRec1 f :*: unRec1 g

    data D1ConProduct
    data C1_ConProduct

    instance Datatype D1ConProduct where
        datatypeName _ = ":*:"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_ConProduct where
        conName   _ = ":*:"
        conFixity _ = Infix RightAssociative 6

    -----

    type Rep1ConCompose f g =
        D1 D1ConCompose (C1 C1_0ConCompose (S1 S1_0_0ConCompose (f :.: Rec1 g)))

    instance Functor f => Generic1 (f :.: g) where
        type Rep1 (f :.: g) = Rep1ConCompose f g
        from1 (Comp1 c) = M1 (M1 (M1 (Comp1 (fmap Rec1 c))))
        to1 (M1 (M1 (M1 c))) = Comp1 (fmap unRec1 (unComp1 c))

    data D1ConCompose
    data C1_0ConCompose
    data S1_0_0ConCompose

    instance Datatype D1ConCompose where
        datatypeName _ = ":.:"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0ConCompose where
      conName     _ = "Comp1"
      conIsRecord _ = True

    instance Selector S1_0_0ConCompose where
      selName _ = "unComp1"

    -----

    type Rep1K1 i c = D1 D1K1 (C1 C1_0K1 (S1 S1_0_0K1 (Rec0 c)))

    instance Generic1 (K1 i c) where
        type Rep1 (K1 i c) = Rep1K1 i c
        from1 (K1 c) = M1 (M1 (M1 (K1 c)))
        to1 (M1 (M1 (M1 c))) = K1 (unK1 c)

    data D1K1
    data C1_0K1
    data S1_0_0K1

    instance Datatype D1K1 where
        datatypeName _ = "K1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0K1 where
        conName     _ = "K1"
        conIsRecord _ = True

    instance Selector S1_0_0K1 where
        selName _ = "unK1"

    -----

    type Rep1M1 i c f = D1 D1M1 (C1 C1_0M1 (S1 S1_0_0M1 (Rec1 f)))

    instance Generic1 (M1 i c f) where
        type Rep1 (M1 i c f) = Rep1M1 i c f
        from1 (M1 m) = M1 (M1 (M1 (Rec1 m)))
        to1 (M1 (M1 (M1 m))) = M1 (unRec1 m)

    data D1M1
    data C1_0M1
    data S1_0_0M1

    instance Datatype D1M1 where
        datatypeName _ = "M1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0M1 where
        conName     _ = "M1"
        conIsRecord _ = True

    instance Selector S1_0_0M1 where
        selName _ = "unM1"

    -----

    type Rep1Par1 = D1 D1Par1 (C1 C1_0Par1 (S1 S1_0_0Par1 Par1))

    instance Generic1 Par1 where
        type Rep1 Par1 = Rep1Par1
        from1 (Par1 p) = M1 (M1 (M1 (Par1 p)))
        to1 (M1 (M1 (M1 p))) = Par1 (unPar1 p)

    data D1Par1
    data C1_0Par1
    data S1_0_0Par1

    instance Datatype D1Par1 where
        datatypeName _ = "Par1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0Par1 where
        conName     _ = "Par1"
        conIsRecord _ = True

    instance Selector S1_0_0Par1 where
        selName _ = "unPar1"

    -----

    type Rep1Rec1 f = D1 D1Rec1 (C1 C1_0Rec1 (S1 S1_0_0Rec1 (Rec1 f)))

    instance Generic1 (Rec1 f) where
        type Rep1 (Rec1 f) = Rep1Rec1 f
        from1 (Rec1 r) = M1 (M1 (M1 (Rec1 r)))
        to1 (M1 (M1 (M1 r))) = Rec1 (unRec1 r)

    data D1Rec1
    data C1_0Rec1
    data S1_0_0Rec1

    instance Datatype D1Rec1 where
        datatypeName _ = "Rec1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0Rec1 where
        conName     _ = "Rec1"
        conIsRecord _ = True

    instance Selector S1_0_0Rec1 where
        selName _ = "unRec1"

    -----

    type Rep1U1 = D1 D1U1 (C1 C1_0U1 U1)

    instance Generic1 U1 where
        type Rep1 U1 = Rep1U1
        from1 U1 = M1 (M1 U1)
        to1 (M1 (M1 U1)) = U1

    data D1U1
    data C1_0U1

    instance Datatype D1U1 where
        datatypeName _ = "U1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0U1 where
        conName _ = "U1"

    -----

    type Rep0V1 p = D1 D1V1 V1
    type Rep1V1   = D1 D1V1 V1

    instance Generic (V1 p) where
        type Rep (V1 p) = Rep0V1 p
        from x = M1 (case x of !_ -> error "No generic representation for empty datatype V1")
        to (M1 !_) = error "No values for empty datatype V1"

    instance Generic1 V1 where
        type Rep1 V1 = Rep1V1
        from1 x = M1 (case x of !_ -> error "No generic representation for empty datatype V1")
        to1 (M1 !_) = error "No values for empty datatype V1"

    data D1V1

    instance Datatype D1V1 where
        datatypeName _ = "V1"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    -----

    type Rep0UAddr p = D1 D1UAddr (C1 C1_0UAddr (S1 S1_0_0UAddr UAddr))
    type Rep1UAddr   = D1 D1UAddr (C1 C1_0UAddr (S1 S1_0_0UAddr UAddr))

    instance Generic (UAddr p) where
        type Rep (UAddr p) = Rep0UAddr p
        from (UAddr a) = M1 (M1 (M1 (UAddr a)))
        to (M1 (M1 (M1 (UAddr a)))) = UAddr a

    instance Generic1 UAddr where
        type Rep1 UAddr = Rep1UAddr
        from1 (UAddr a) = M1 (M1 (M1 (UAddr a)))
        to1 (M1 (M1 (M1 (UAddr a)))) = UAddr a

    data D1UAddr
    data C1_0UAddr
    data S1_0_0UAddr

    instance Datatype D1UAddr where
        datatypeName _ = "UAddr"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UAddr where
        conName     _ = "UAddr"
        conIsRecord _ = True

    instance Selector S1_0_0UAddr where
        selName _ = "uAddr#"

    -----

    type Rep0UChar p = D1 D1UChar (C1 C1_0UChar (S1 S1_0_0UChar UChar))
    type Rep1UChar   = D1 D1UChar (C1 C1_0UChar (S1 S1_0_0UChar UChar))

    instance Generic (UChar p) where
        type Rep (UChar p) = Rep0UChar p
        from (UChar c) = M1 (M1 (M1 (UChar c)))
        to (M1 (M1 (M1 (UChar c)))) = UChar c

    instance Generic1 UChar where
        type Rep1 UChar = Rep1UChar
        from1 (UChar c) = M1 (M1 (M1 (UChar c)))
        to1 (M1 (M1 (M1 (UChar c)))) = UChar c

    data D1UChar
    data C1_0UChar
    data S1_0_0UChar

    instance Datatype D1UChar where
        datatypeName _ = "UChar"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UChar where
        conName     _ = "UChar"
        conIsRecord _ = True

    instance Selector S1_0_0UChar where
        selName _ = "uChar#"

    -----

    type Rep0UDouble p = D1 D1UDouble (C1 C1_0UDouble (S1 S1_0_0UDouble UDouble))
    type Rep1UDouble   = D1 D1UDouble (C1 C1_0UDouble (S1 S1_0_0UDouble UDouble))

    instance Generic (UDouble p) where
        type Rep (UDouble p) = Rep0UDouble p
        from (UDouble d) = M1 (M1 (M1 (UDouble d)))
        to (M1 (M1 (M1 (UDouble d)))) = UDouble d

    instance Generic1 UDouble where
        type Rep1 UDouble = Rep1UDouble
        from1 (UDouble d) = M1 (M1 (M1 (UDouble d)))
        to1 (M1 (M1 (M1 (UDouble d)))) = UDouble d

    data D1UDouble
    data C1_0UDouble
    data S1_0_0UDouble

    instance Datatype D1UDouble where
        datatypeName _ = "UDouble"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UDouble where
        conName     _ = "UDouble"
        conIsRecord _ = True

    instance Selector S1_0_0UDouble where
        selName _ = "uDouble#"

    -----

    type Rep0UFloat p = D1 D1UFloat (C1 C1_0UFloat (S1 S1_0_0UFloat UFloat))
    type Rep1UFloat   = D1 D1UFloat (C1 C1_0UFloat (S1 S1_0_0UFloat UFloat))

    instance Generic (UFloat p) where
        type Rep (UFloat p) = Rep0UFloat p
        from (UFloat f) = M1 (M1 (M1 (UFloat f)))
        to (M1 (M1 (M1 (UFloat f)))) = UFloat f

    instance Generic1 UFloat where
        type Rep1 UFloat = Rep1UFloat
        from1 (UFloat f) = M1 (M1 (M1 (UFloat f)))
        to1 (M1 (M1 (M1 (UFloat f)))) = UFloat f

    data D1UFloat
    data C1_0UFloat
    data S1_0_0UFloat

    instance Datatype D1UFloat where
        datatypeName _ = "UFloat"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UFloat where
        conName     _ = "UFloat"
        conIsRecord _ = True

    instance Selector S1_0_0UFloat where
        selName _ = "uFloat#"

    -----

    type Rep0UInt p = D1 D1UInt (C1 C1_0UInt (S1 S1_0_0UInt UInt))
    type Rep1UInt   = D1 D1UInt (C1 C1_0UInt (S1 S1_0_0UInt UInt))

    instance Generic (UInt p) where
        type Rep (UInt p) = Rep0UInt p
        from (UInt i) = M1 (M1 (M1 (UInt i)))
        to (M1 (M1 (M1 (UInt i)))) = UInt i

    instance Generic1 UInt where
        type Rep1 UInt = Rep1UInt
        from1 (UInt i) = M1 (M1 (M1 (UInt i)))
        to1 (M1 (M1 (M1 (UInt i)))) = UInt i

    data D1UInt
    data C1_0UInt
    data S1_0_0UInt

    instance Datatype D1UInt where
        datatypeName _ = "UInt"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UInt where
        conName     _ = "UInt"
        conIsRecord _ = True

    instance Selector S1_0_0UInt where
        selName _ = "uInt#"

    -----

    type Rep0UWord p = D1 D1UWord (C1 C1_0UWord (S1 S1_0_0UWord UWord))
    type Rep1UWord   = D1 D1UWord (C1 C1_0UWord (S1 S1_0_0UWord UWord))

    instance Generic (UWord p) where
        type Rep (UWord p) = Rep0UWord p
        from (UWord w) = M1 (M1 (M1 (UWord w)))
        to (M1 (M1 (M1 (UWord w)))) = UWord w

    instance Generic1 UWord where
        type Rep1 UWord = Rep1UWord
        from1 (UWord w) = M1 (M1 (M1 (UWord w)))
        to1 (M1 (M1 (M1 (UWord w)))) = UWord w

    data D1UWord
    data C1_0UWord
    data S1_0_0UWord

    instance Datatype D1UWord where
        datatypeName _ = "UWord"
        moduleName   _ = "Generics.Deriving.Base.Internal"

    instance Constructor C1_0UWord where
        conName     _ = "UWord"
        conIsRecord _ = True

    instance Selector S1_0_0UWord where
        selName _ = "uWord#"

    -----

    # if MIN_VERSION_base(4,4,0)
    type Rep0Complex a = D1 D1Complex (C1 C1_0Complex (S1 NoSelector (Rec0 a)
                                                   :*: S1 NoSelector (Rec0 a)))
    type Rep1Complex = D1 D1Complex (C1 C1_0Complex (S1 NoSelector Par1
                                                 :*: S1 NoSelector Par1))

    instance Generic (Complex a) where
        type Rep (Complex a) = Rep0Complex a
        from (a :+ b) = M1 (M1 (M1 (K1 a) :*: M1 (K1 b)))
        to (M1 (M1 (M1 (K1 a) :*: M1 (K1 b)))) = a :+ b

    instance Generic1 Complex where
        type Rep1 Complex = Rep1Complex
        from1 (a :+ b) = M1 (M1 (M1 (Par1 a) :*: M1 (Par1 b)))
        to1 (M1 (M1 (M1 a :*: M1 b))) = unPar1 a :+ unPar1 b

    data D1Complex
    data C1_0Complex

    instance Datatype D1Complex where
        datatypeName _ = "Complex"
        moduleName   _ = "Data.Complex"

    instance Constructor C1_0Complex where
        conName   _ = ":+"
        conFixity _ = Infix LeftAssociative 9
    # endif

    -----

    # if MIN_VERSION_base(4,7,0)
    type Rep1Proxy = D1 D1Proxy (C1 C1_0Proxy U1)

    instance Generic1 Proxy where
        type Rep1 Proxy = Rep1Proxy
        from1 Proxy      = M1 (M1 U1)
        to1 (M1 (M1 U1)) = Proxy

    data D1Proxy
    data C1_0Proxy

    instance Datatype D1Proxy where
        datatypeName _ = "Proxy"
        moduleName   _ = "Data.Proxy"

    instance Constructor C1_0Proxy where
        conName _ = "Proxy"
    # endif
    #endif

    -----

    #if !(MIN_VERSION_base(4,7,0))
    --------------------------------------------------------------------------------
    -- Representations for base types
    --------------------------------------------------------------------------------

    type Rep0All = D1 D1All (C1 C1_0All (S1 S1_0_0All (Rec0 Bool)))

    instance Generic All where
        type Rep All = Rep0All
        from (All a) = M1 (M1 (M1 (K1 a)))
        to (M1 (M1 (M1 (K1 a)))) = All a

    data D1All
    data C1_0All
    data S1_0_0All

    instance Datatype D1All where
        datatypeName _ = "All"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0All where
        conName     _ = "All"
        conIsRecord _ = True

    instance Selector S1_0_0All where
        selName _ = "getAll"

    -----

    type Rep0Any = D1 D1Any (C1 C1_0Any (S1 S1_0_0Any (Rec0 Bool)))

    instance Generic Any where
        type Rep Any = Rep0Any
        from (Any a) = M1 (M1 (M1 (K1 a)))
        to (M1 (M1 (M1 (K1 a)))) = Any a

    data D1Any
    data C1_0Any
    data S1_0_0Any

    instance Datatype D1Any where
        datatypeName _ = "Any"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Any where
        conName     _ = "Any"
        conIsRecord _ = True

    instance Selector S1_0_0Any where
        selName _ = "getAny"

    -----

    type Rep0Arity = D1 D1Arity (C1 C1_0Arity U1
                             :+: C1 C1_1Arity (S1 NoSelector (Rec0 Int)))

    instance Generic Arity where
        type Rep Arity = Rep0Arity

        from x = M1 (case x of
            NoArity -> L1 (M1 U1)
            Arity a -> R1 (M1 (M1 (K1 a))))

        to (M1 x) = case x of
            L1 (M1 U1)          -> NoArity
            R1 (M1 (M1 (K1 a))) -> Arity a

    data D1Arity
    data C1_0Arity
    data C1_1Arity

    instance Datatype D1Arity where
        datatypeName _ = "Arity"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0Arity where
        conName _ = "NoArity"

    instance Constructor C1_1Arity where
        conName _ = "Arity"

    -----

    type Rep0Associativity = D1 D1Associativity (C1 C1_0Associativity U1
                                            :+: (C1 C1_1Associativity U1
                                            :+:  C1 C1_2Associativity U1))

    instance Generic Associativity where
        type Rep Associativity = Rep0Associativity

        from x = M1 (case x of
            LeftAssociative  -> L1 (M1 U1)
            RightAssociative -> R1 (L1 (M1 U1))
            NotAssociative   -> R1 (R1 (M1 U1)))

        to (M1 x) = case x of
            L1 (M1 U1)      -> LeftAssociative
            R1 (L1 (M1 U1)) -> RightAssociative
            R1 (R1 (M1 U1)) -> NotAssociative

    data D1Associativity
    data C1_0Associativity
    data C1_1Associativity
    data C1_2Associativity

    instance Datatype D1Associativity where
        datatypeName _ = "Associativity"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0Associativity where
        conName _ = "LeftAssociative"

    instance Constructor C1_1Associativity where
        conName _ = "RightAssociative"

    instance Constructor C1_2Associativity where
        conName _ = "NotAssociative"

    -----

    type Rep0Const a b = D1 D1Const (C1 C1_0Const (S1 S1_0_0Const (Rec0 a)))
    type Rep1Const a   = D1 D1Const (C1 C1_0Const (S1 S1_0_0Const (Rec0 a)))

    instance Generic (Const a b) where
        type Rep (Const a b) = Rep0Const a b
        from (Const a) = M1 (M1 (M1 (K1 a)))
        to (M1 (M1 (M1 (K1 a)))) = Const a

    instance Generic1 (Const a) where
        type Rep1 (Const a) = Rep1Const a
        from1 (Const a) = M1 (M1 (M1 (K1 a)))
        to1 (M1 (M1 (M1 (K1 a)))) = Const a

    data D1Const
    data C1_0Const
    data S1_0_0Const

    instance Datatype D1Const where
        datatypeName _ = "Const"
        moduleName   _ = "Control.Applicative"

    instance Constructor C1_0Const where
        conName     _ = "Const"
        conIsRecord _ = True

    instance Selector S1_0_0Const where
        selName _ = "getConst"

    -----

    type Rep0Dual a = D1 D1Dual (C1 C1_0Dual (S1 S1_0_0Dual (Rec0 a)))
    type Rep1Dual   = D1 D1Dual (C1 C1_0Dual (S1 S1_0_0Dual Par1))

    instance Generic (Dual a) where
        type Rep (Dual a) = Rep0Dual a
        from (Dual d) = M1 (M1 (M1 (K1 d)))
        to (M1 (M1 (M1 (K1 d)))) = Dual d

    instance Generic1 Dual where
        type Rep1 Dual = Rep1Dual
        from1 (Dual d) = M1 (M1 (M1 (Par1 d)))
        to1 (M1 (M1 (M1 (Par1 d)))) = Dual d

    data D1Dual
    data C1_0Dual
    data S1_0_0Dual

    instance Datatype D1Dual where
        datatypeName _ = "Dual"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Dual where
        conName     _ = "Dual"
        conIsRecord _ = True

    instance Selector S1_0_0Dual where
        selName _ = "getDual"

    -----

    type Rep0Endo a = D1 D1Endo (C1 C1_0Endo (S1 S1_0_0Endo (Rec0 (a -> a))))

    instance Generic (Endo a) where
        type Rep (Endo a) = Rep0Endo a
        from (Endo e) = M1 (M1 (M1 (K1 e)))
        to (M1 (M1 (M1 (K1 e)))) = Endo e

    data D1Endo
    data C1_0Endo
    data S1_0_0Endo

    instance Datatype D1Endo where
        datatypeName _ = "Endo"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Endo where
        conName     _ = "Endo"
        conIsRecord _ = True

    instance Selector S1_0_0Endo where
        selName _ = "appEndo"

    -----

    type Rep0First a = D1 D1First (C1 C1_0First (S1 S1_0_0First (Rec0 (Maybe a))))
    type Rep1First   = D1 D1First (C1 C1_0First (S1 S1_0_0First (Rec1 Maybe)))

    instance Generic (First a) where
        type Rep (First a) = Rep0First a
        from (First f) = M1 (M1 (M1 (K1 f)))
        to (M1 (M1 (M1 (K1 f)))) = First f

    instance Generic1 First where
        type Rep1 First = Rep1First
        from1 (First f) = M1 (M1 (M1 (Rec1 f)))
        to1 (M1 (M1 (M1 (Rec1 f)))) = First f

    data D1First
    data C1_0First
    data S1_0_0First

    instance Datatype D1First where
        datatypeName _ = "First"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0First where
        conName     _ = "First"
        conIsRecord _ = True

    instance Selector S1_0_0First where
        selName _ = "getFirst"

    -----

    type Rep0Fixity = D1 D1Fixity (C1 C1_0Fixity U1
                               :+: C1 C1_1Fixity (S1 NoSelector (Rec0 Associativity)
                                              :*: S1 NoSelector (Rec0 Int)))

    instance Generic Fixity where
        type Rep Fixity = Rep0Fixity

        from x = M1 (case x of
            Prefix    -> L1 (M1 U1)
            Infix a i -> R1 (M1 (M1 (K1 a) :*: M1 (K1 i))))

        to (M1 x) = case x of
            L1 (M1 U1)                        -> Prefix
            R1 (M1 (M1 (K1 a) :*: M1 (K1 i))) -> Infix a i

    data D1Fixity
    data C1_0Fixity
    data C1_1Fixity

    instance Datatype D1Fixity where
        datatypeName _ = "Fixity"
    # if !(MIN_VERSION_base(4,4,0))
        moduleName   _ = "Generics.Deriving.Base.Internal"
    # else
        moduleName   _ = "GHC.Generics"
    # endif

    instance Constructor C1_0Fixity where
        conName _ = "Prefix"

    instance Constructor C1_1Fixity where
        conName _ = "Infix"

    -----

    type Rep0Last a = D1 D1Last (C1 C1_0Last (S1 S1_0_0Last (Rec0 (Maybe a))))
    type Rep1Last   = D1 D1Last (C1 C1_0Last (S1 S1_0_0Last (Rec1 Maybe)))

    instance Generic (Last a) where
        type Rep (Last a) = Rep0Last a
        from (Last l) = M1 (M1 (M1 (K1 l)))
        to (M1 (M1 (M1 (K1 l)))) = Last l

    instance Generic1 Last where
        type Rep1 Last = Rep1Last
        from1 (Last l) = M1 (M1 (M1 (Rec1 l)))
        to1 (M1 (M1 (M1 (Rec1 l)))) = Last l

    data D1Last
    data C1_0Last
    data S1_0_0Last

    instance Datatype D1Last where
        datatypeName _ = "Last"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Last where
        conName     _ = "Last"
        conIsRecord _ = True

    instance Selector S1_0_0Last where
        selName _ = "getLast"

    -----

    type Rep0Product a = D1 D1Product (C1 C1_0Product (S1 S1_0_0Product (Rec0 a)))
    type Rep1Product   = D1 D1Product (C1 C1_0Product (S1 S1_0_0Product Par1))

    instance Generic (Product a) where
        type Rep (Product a) = Rep0Product a
        from (Product p) = M1 (M1 (M1 (K1 p)))
        to (M1 (M1 (M1 (K1 p)))) = Product p

    instance Generic1 Product where
        type Rep1 Product = Rep1Product
        from1 (Product p) = M1 (M1 (M1 (Par1 p)))
        to1 (M1 (M1 (M1 (Par1 p)))) = Product p

    data D1Product
    data C1_0Product
    data S1_0_0Product

    instance Datatype D1Product where
        datatypeName _ = "Product"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Product where
        conName     _ = "Product"
        conIsRecord _ = True

    instance Selector S1_0_0Product where
        selName _ = "getProduct"

    -----

    type Rep0Sum a = D1 D1Sum (C1 C1_0Sum (S1 S1_0_0Sum (Rec0 a)))
    type Rep1Sum   = D1 D1Sum (C1 C1_0Sum (S1 S1_0_0Sum Par1))

    instance Generic (Sum a) where
        type Rep (Sum a) = Rep0Sum a
        from (Sum s) = M1 (M1 (M1 (K1 s)))
        to (M1 (M1 (M1 (K1 s)))) = Sum s

    instance Generic1 Sum where
        type Rep1 Sum = Rep1Sum
        from1 (Sum s) = M1 (M1 (M1 (Par1 s)))
        to1 (M1 (M1 (M1 (Par1 s)))) = Sum s

    data D1Sum
    data C1_0Sum
    data S1_0_0Sum

    instance Datatype D1Sum where
        datatypeName _ = "Sum"
        moduleName   _ = "Data.Monoid"

    instance Constructor C1_0Sum where
        conName     _ = "Sum"
        conIsRecord _ = True

    instance Selector S1_0_0Sum where
        selName _ = "getSum"

    -----

    type Rep0WrappedArrow a b c =
        D1 D1WrappedArrow (C1 C1_0WrappedArrow (S1 S1_0_0WrappedArrow (Rec0 (a b c))))
    type Rep1WrappedArrow a b =
        D1 D1WrappedArrow (C1 C1_0WrappedArrow (S1 S1_0_0WrappedArrow (Rec1 (a b))))

    instance Generic (WrappedArrow a b c) where
        type Rep (WrappedArrow a b c) = Rep0WrappedArrow a b c
        from (WrapArrow a) = M1 (M1 (M1 (K1 a)))
        to (M1 (M1 (M1 (K1 a)))) = WrapArrow a

    instance Generic1 (WrappedArrow a b) where
        type Rep1 (WrappedArrow a b) = Rep1WrappedArrow a b
        from1 (WrapArrow a) = M1 (M1 (M1 (Rec1 a)))
        to1 (M1 (M1 (M1 (Rec1 a)))) = WrapArrow a

    data D1WrappedArrow
    data C1_0WrappedArrow
    data S1_0_0WrappedArrow

    instance Datatype D1WrappedArrow where
      datatypeName _ = "WrappedArrow"
      moduleName   _ = "Control.Applicative"

    instance Constructor C1_0WrappedArrow where
      conName     _ = "WrapArrow"
      conIsRecord _ = True

    instance Selector S1_0_0WrappedArrow where
      selName _ = "unwrapArrow"

    -----

    type Rep0WrappedMonad m a =
        D1 D1WrappedMonad (C1 C1_0WrappedMonad (S1 S1_0_0WrappedMonad (Rec0 (m a))))
    type Rep1WrappedMonad m =
        D1 D1WrappedMonad (C1 C1_0WrappedMonad (S1 S1_0_0WrappedMonad (Rec1 m)))

    instance Generic (WrappedMonad m a) where
        type Rep (WrappedMonad m a) = Rep0WrappedMonad m a
        from (WrapMonad m) = M1 (M1 (M1 (K1 m)))
        to (M1 (M1 (M1 (K1 m)))) = WrapMonad m

    instance Generic1 (WrappedMonad m) where
        type Rep1 (WrappedMonad m) = Rep1WrappedMonad m
        from1 (WrapMonad m) = M1 (M1 (M1 (Rec1 m)))
        to1 (M1 (M1 (M1 (Rec1 m)))) = WrapMonad m

    data D1WrappedMonad
    data C1_0WrappedMonad
    data S1_0_0WrappedMonad

    instance Datatype D1WrappedMonad where
        datatypeName _ = "WrappedMonad"
        moduleName   _ = "Control.Applicative"

    instance Constructor C1_0WrappedMonad where
        conName     _ = "WrapMonad"
        conIsRecord _ = True

    instance Selector S1_0_0WrappedMonad where
        selName _ = "unwrapMonad"

    -----

    type Rep0ZipList a = D1 D1ZipList (C1 C1_0ZipList (S1 S1_0_0ZipList (Rec0 [a])))
    type Rep1ZipList   = D1 D1ZipList (C1 C1_0ZipList (S1 S1_0_0ZipList (Rec1 [])))

    instance Generic (ZipList a) where
        type Rep (ZipList a) = Rep0ZipList a
        from (ZipList z) = M1 (M1 (M1 (K1 z)))
        to (M1 (M1 (M1 (K1 z)))) = ZipList z

    instance Generic1 ZipList where
        type Rep1 ZipList = Rep1ZipList
        from1 (ZipList z) = M1 (M1 (M1 (Rec1 z)))
        to1 (M1 (M1 (M1 (Rec1 z)))) = ZipList z

    data D1ZipList
    data C1_0ZipList
    data S1_0_0ZipList

    instance Datatype D1ZipList where
        datatypeName _ = "ZipList"
        moduleName   _ = "Control.Applicative"

    instance Constructor C1_0ZipList where
        conName     _ = "ZipList"
        conIsRecord _ = True

    instance Selector S1_0_0ZipList where
        selName _ = "getZipList"

    -----

    type Rep0U1 p = D1 D1U1 (C1 C1_0U1 U1)

    instance Generic (U1 p) where
        type Rep (U1 p) = Rep0U1 p
        from U1 = M1 (M1 U1)
        to (M1 (M1 U1)) = U1

    -----

    type Rep0Par1 p = D1 D1Par1 (C1 C1_0Par1 (S1 S1_0_0Par1 (Rec0 p)))

    instance Generic (Par1 p) where
        type Rep (Par1 p) = Rep0Par1 p
        from (Par1 p) = M1 (M1 (M1 (K1 p)))
        to (M1 (M1 (M1 (K1 p)))) = Par1 p

    -----

    type Rep0Rec1 f p = D1 D1Rec1 (C1 C1_0Rec1 (S1 S1_0_0Rec1 (Rec0 (f p))))

    instance Generic (Rec1 f p) where
        type Rep (Rec1 f p) = Rep0Rec1 f p
        from (Rec1 r) = M1 (M1 (M1 (K1 r)))
        to (M1 (M1 (M1 (K1 r)))) = Rec1 r

    -----

    type Rep0K1 i c p = D1 D1K1 (C1 C1_0K1 (S1 S1_0_0K1 (Rec0 c)))

    instance Generic (K1 i c p) where
        type Rep (K1 i c p) = Rep0K1 i c p
        from (K1 c) = M1 (M1 (M1 (K1 c)))
        to (M1 (M1 (M1 (K1 c)))) = K1 c

    -----

    type Rep0M1 i c f p = D1 D1M1 (C1 C1_0M1 (S1 S1_0_0M1 (Rec0 (f p))))

    instance Generic (M1 i c f p) where
        type Rep (M1 i c f p) = Rep0M1 i c f p
        from (M1 m) = M1 (M1 (M1 (K1 m)))
        to (M1 (M1 (M1 (K1 m)))) = M1 m

    -----

    type Rep0ConSum f g p = D1 D1ConSum (C1 C1_0ConSum (S1 NoSelector (Rec0 (f p)))
                                     :+: C1 C1_1ConSum (S1 NoSelector (Rec0 (g p))))

    instance Generic ((f :+: g) p) where
        type Rep ((f :+: g) p) = Rep0ConSum f g p

        from x = M1 (case x of
            L1 l -> L1 (M1 (M1 (K1 l)))
            R1 r -> R1 (M1 (M1 (K1 r))))

        to (M1 x) = case x of
            L1 (M1 (M1 (K1 l))) -> L1 l
            R1 (M1 (M1 (K1 r))) -> R1 r

    -----

    type Rep0ConProduct f g p =
        D1 D1ConProduct (C1 C1_ConProduct (S1 NoSelector (Rec0 (f p))
                                       :*: S1 NoSelector (Rec0 (g p))))

    instance Generic ((f :*: g) p) where
        type Rep ((f :*: g) p) = Rep0ConProduct f g p
        from (f :*: g) = M1 (M1 (M1 (K1 f) :*: M1 (K1 g)))
        to (M1 (M1 (M1 (K1 f) :*: M1 (K1 g)))) = f :*: g

    -----

    type Rep0ConCompose f g p =
        D1 D1ConCompose (C1 C1_0ConCompose (S1 S1_0_0ConCompose (Rec0 (f (g p)))))

    instance Generic ((f :.: g) p) where
        type Rep ((f :.: g) p) = Rep0ConCompose f g p
        from (Comp1 c) = M1 (M1 (M1 (K1 c)))
        to (M1 (M1 (M1 (K1 c)))) = Comp1 c
    #endif

    -----

    #if !(MIN_VERSION_base(4,6,0))
    type Rep1List = D1 D1List (C1 C1_0List U1 :+:
                               C1 C1_1List (S1 NoSelector Par1
                                        :*: S1 NoSelector (Rec1 [])))

    instance Generic1 [] where
        type Rep1 [] = Rep1List

        from1 x = M1 (case x of
            []  -> L1 (M1 U1)
            h:t -> R1 (M1 (M1 (Par1 h) :*: M1 (Rec1 t))))

        to1 (M1 x) = case x of
            L1 (M1 U1)                            -> []
            R1 (M1 (M1 (Par1 h) :*: M1 (Rec1 t))) -> h : t

    data D1List
    data C1_0List
    data C1_1List

    instance Datatype D1List where
        datatypeName _ = "[]"
        moduleName   _ = "GHC.Types"

    instance Constructor C1_0List  where
        conName _ = "[]"

    instance Constructor C1_1List where
        conName   _ = ":"
        conFixity _ = Infix RightAssociative 5

    -----

    type Rep1Either a = D1 D1Either (C1 C1_0Either (S1 NoSelector (Rec0 a))
                                 :+: C1 C1_1Either (S1 NoSelector Par1))

    instance Generic1 (Either a) where
        type Rep1 (Either a) = Rep1Either a

        from1 x = M1 (case x of
            Left  l -> L1 (M1 (M1 (K1 l)))
            Right r -> R1 (M1 (M1 (Par1 r))))

        to1 (M1 x) = case x of
            L1 (M1 (M1 (K1 l)))   -> Left l
            R1 (M1 (M1 (Par1 r))) -> Right r

    data D1Either
    data C1_0Either
    data C1_1Either

    instance Datatype D1Either where
        datatypeName _ = "Either"
        moduleName   _ = "Data.Either"

    instance Constructor C1_0Either where
        conName _ = "Left"

    instance Constructor C1_1Either where
        conName _ = "Right"

    -----

    type Rep1Maybe = D1 D1Maybe (C1 C1_0Maybe U1
                             :+: C1 C1_1Maybe (S1 NoSelector Par1))

    instance Generic1 Maybe where
        type Rep1 Maybe = Rep1Maybe

        from1 x = M1 (case x of
            Nothing -> L1 (M1 U1)
            Just j  -> R1 (M1 (M1 (Par1 j))))

        to1 (M1 x) = case x of
            L1 (M1 U1)            -> Nothing
            R1 (M1 (M1 (Par1 j))) -> Just j

    data D1Maybe
    data C1_0Maybe
    data C1_1Maybe

    instance Datatype D1Maybe where
        datatypeName _ = "Maybe"
        -- As of base-4.7.0.0, Maybe is actually located in GHC.Base.
        -- We don't need to worry about this for the versions of base
        -- that this instance is defined for, however.
        moduleName   _ = "Data.Maybe"

    instance Constructor C1_0Maybe where
        conName _ = "Nothing"

    instance Constructor C1_1Maybe where
        conName _ = "Just"

    -----

    type Rep1Tuple2 a = D1 D1Tuple2 (C1 C1_0Tuple2 (S1 NoSelector (Rec0 a)
                                                :*: S1 NoSelector Par1))

    instance Generic1 ((,) a) where
        type Rep1 ((,) a) = Rep1Tuple2 a
        from1 (a, b) = M1 (M1 (M1 (K1 a) :*: M1 (Par1 b)))
        to1 (M1 (M1 (M1 (K1 a) :*: M1 (Par1 b)))) = (a, b)

    data D1Tuple2
    data C1_0Tuple2

    instance Datatype D1Tuple2 where
        datatypeName _ = "(,)"
        moduleName   _ = "GHC.Tuple"

    instance Constructor C1_0Tuple2 where
        conName _ = "(,)"

    -----

    type Rep1Tuple3 a b = D1 D1Tuple3 (C1 C1_0Tuple3 (S1 NoSelector (Rec0 a)
                                                 :*: (S1 NoSelector (Rec0 b)
                                                 :*:  S1 NoSelector Par1)))

    instance Generic1 ((,,) a b) where
        type Rep1 ((,,) a b) = Rep1Tuple3 a b
        from1 (a, b, c) = M1 (M1 (M1 (K1 a) :*: (M1 (K1 b) :*: M1 (Par1 c))))
        to1 (M1 (M1 (M1 (K1 a) :*: (M1 (K1 b) :*: M1 (Par1 c))))) = (a, b, c)

    data D1Tuple3
    data C1_0Tuple3

    instance Datatype D1Tuple3 where
        datatypeName _ = "(,,)"
        moduleName   _ = "GHC.Tuple"

    instance Constructor C1_0Tuple3 where
        conName _ = "(,,)"

    -----

    type Rep1Tuple4 a b c = D1 D1Tuple4 (C1 C1_0Tuple4 ((S1 NoSelector (Rec0 a)
                                                    :*:  S1 NoSelector (Rec0 b))
                                                    :*: (S1 NoSelector (Rec0 c)
                                                    :*:  S1 NoSelector Par1)))

    instance Generic1 ((,,,) a b c) where
        type Rep1 ((,,,) a b c) = Rep1Tuple4 a b c

        from1 (a, b, c, d) = M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                                 :*: (M1 (K1 c) :*: M1 (Par1 d))))

        to1 (M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                 :*: (M1 (K1 c) :*: M1 (Par1 d)))))
          = (a, b, c, d)

    data D1Tuple4
    data C1_0Tuple4

    instance Datatype D1Tuple4 where
        datatypeName _ = "(,,,)"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Tuple4 where
        conName _ = "(,,,)"

    -----

    type Rep1Tuple5 a b c d = D1 D1Tuple5 (C1 C1_0Tuple5 ((S1 NoSelector (Rec0 a)
                                                      :*:  S1 NoSelector (Rec0 b))
                                                      :*: (S1 NoSelector (Rec0 c)
                                                      :*: (S1 NoSelector (Rec0 d)
                                                      :*:  S1 NoSelector Par1))))

    instance Generic1 ((,,,,) a b c d) where
        type Rep1 ((,,,,) a b c d) = Rep1Tuple5 a b c d

        from1 (a, b, c, d, e) = M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                                    :*: (M1 (K1 c) :*: (M1 (K1 d) :*: M1 (Par1 e)))))

        to1 (M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                 :*: (M1 (K1 c) :*: (M1 (K1 d) :*: M1 (Par1 e))))))
          = (a, b, c, d, e)

    data D1Tuple5
    data C1_0Tuple5

    instance Datatype D1Tuple5 where
        datatypeName _ = "(,,,,)"
        moduleName   _ = "GHC.Tuple"

    instance Constructor C1_0Tuple5 where
        conName _ = "(,,,,)"

    -----

    type Rep1Tuple6 a b c d e =
        D1 D1Tuple6 (C1 C1_0Tuple6 ((S1 NoSelector (Rec0 a)
                                :*: (S1 NoSelector (Rec0 b)
                                :*:  S1 NoSelector (Rec0 c)))
                                :*: (S1 NoSelector (Rec0 d)
                                :*: (S1 NoSelector (Rec0 e)
                                :*:  S1 NoSelector Par1))))

    instance Generic1 ((,,,,,) a b c d e) where
        type Rep1 ((,,,,,) a b c d e) = Rep1Tuple6 a b c d e

        from1 (a, b, c, d, e, f) = M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                                       :*: (M1 (K1 d) :*: (M1 (K1 e) :*: M1 (Par1 f)))))

        to1 (M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                 :*: (M1 (K1 d) :*: (M1 (K1 e) :*: M1 (Par1 f))))))
          = (a, b, c, d, e, f)

    data D1Tuple6
    data C1_0Tuple6

    instance Datatype D1Tuple6 where
        datatypeName _ = "(,,,,,)"
        moduleName   _ = "GHC.Tuple"

    instance Constructor C1_0Tuple6 where
        conName _ = "(,,,,,)"

    -----

    type Rep1Tuple7 a b c d e f =
        D1 D1Tuple7 (C1 C1_0Tuple7 ((S1 NoSelector (Rec0 a)
                               :*:  (S1 NoSelector (Rec0 b)
                               :*:   S1 NoSelector (Rec0 c)))
                               :*: ((S1 NoSelector (Rec0 d)
                               :*:   S1 NoSelector (Rec0 e))
                               :*:  (S1 NoSelector (Rec0 f)
                               :*:   S1 NoSelector Par1))))

    instance Generic1 ((,,,,,,) a b c d e f) where
        type Rep1 ((,,,,,,) a b c d e f) = Rep1Tuple7 a b c d e f

        from1 (a, b, c, d, e, f, g) = M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                          :*: ((M1 (K1 d) :*: M1 (K1 e)) :*: (M1 (K1 f) :*: M1 (Par1 g)))))

        to1 (M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                :*: ((M1 (K1 d) :*: M1 (K1 e)) :*: (M1 (K1 f) :*: M1 (Par1 g))))))
          = (a, b, c, d, e, f, g)

    data D1Tuple7
    data C1_0Tuple7

    instance Datatype D1Tuple7 where
        datatypeName _ = "(,,,,,,)"
        moduleName   _ = "GHC.Tuple"

    instance Constructor C1_0Tuple7 where
        conName _ = "(,,,,,,)"
    #endif

    -----

    #if !(MIN_VERSION_base(4,4,0))
    type Rep0Bool = D1 D1Bool (C1 C1_0Bool U1 :+: C1 C1_1Bool U1)

    instance Generic Bool where
        type Rep Bool = Rep0Bool

        from x = M1 (case x of
            False -> L1 (M1 U1)
            True  -> R1 (M1 U1))

        to (M1 x) = case x of
            L1 (M1 U1) -> False
            R1 (M1 U1) -> True

    data D1Bool
    data C1_0Bool
    data C1_1Bool

    instance Datatype D1Bool where
        datatypeName _ = "Bool"
        moduleName _ = "GHC.Bool"

    instance Constructor C1_0Bool where
        conName _ = "False"

    instance Constructor C1_1Bool where
        conName _ = "True"

    -----

    data D_Char
    data C_Char

    instance Datatype D_Char where
      datatypeName _ = "Char"
      moduleName   _ = "GHC.Base"

    instance Constructor C_Char where
      conName _ = "" -- JPM: I'm not sure this is the right implementation...

    type Rep0Char = D1 D_Char (C1 C_Char (S1 NoSelector (Rec0 Char)))

    instance Generic Char where
      type Rep Char = Rep0Char
      from x = M1 (M1 (M1 (K1 x)))
      to (M1 (M1 (M1 (K1 x)))) = x

    -----

    data D_Double
    data C_Double

    instance Datatype D_Double where
      datatypeName _ = "Double"
      moduleName   _ = "GHC.Float"

    instance Constructor C_Double where
      conName _ = "" -- JPM: I'm not sure this is the right implementation...

    type Rep0Double = D1 D_Double (C1 C_Double (S1 NoSelector (Rec0 Double)))

    instance Generic Double where
      type Rep Double = Rep0Double
      from x = M1 (M1 (M1 (K1 x)))
      to (M1 (M1 (M1 (K1 x)))) = x

    -----

    type Rep0Either a b = D1 D1Either (C1 C1_0Either (S1 NoSelector (Rec0 a))
                                   :+: C1 C1_1Either (S1 NoSelector (Rec0 b)))

    instance Generic (Either a b) where
        type Rep (Either a b) = Rep0Either a b

        from x = M1 (case x of
            Left  l -> L1 (M1 (M1 (K1 l)))
            Right r -> R1 (M1 (M1 (K1 r))))

        to (M1 x) = case x of
            L1 (M1 (M1 (K1 l))) -> Left l
            R1 (M1 (M1 (K1 r))) -> Right r

    -----

    data D_Int
    data C_Int

    instance Datatype D_Int where
      datatypeName _ = "Int"
      moduleName   _ = "GHC.Int"

    instance Constructor C_Int where
      conName _ = "" -- JPM: I'm not sure this is the right implementation...

    type Rep0Int = D1 D_Int (C1 C_Int (S1 NoSelector (Rec0 Int)))

    instance Generic Int where
      type Rep Int = Rep0Int
      from x = M1 (M1 (M1 (K1 x)))
      to (M1 (M1 (M1 (K1 x)))) = x

    -----

    data D_Float
    data C_Float

    instance Datatype D_Float where
      datatypeName _ = "Float"
      moduleName   _ = "GHC.Float"

    instance Constructor C_Float where
      conName _ = "" -- JPM: I'm not sure this is the right implementation...

    type Rep0Float = D1 D_Float (C1 C_Float (S1 NoSelector (Rec0 Float)))

    instance Generic Float where
      type Rep Float = Rep0Float
      from x = M1 (M1 (M1 (K1 x)))
      to (M1 (M1 (M1 (K1 x)))) = x

    -----

    type Rep0List a =
        D1 D1List (C1 C1_0List U1 :+: C1 C1_1List (S1 NoSelector (Rec0 a)
                                               :*: S1 NoSelector (Rec0 [a])))

    instance Generic [a] where
        type Rep [a] = Rep0List a

        from x = M1 (case x of
            []  -> L1 (M1 U1)
            h:t -> R1 (M1 (M1 (K1 h) :*: M1 (K1 t))))

        to (M1 x) = case x of
            L1 (M1 U1)                        -> []
            R1 (M1 (M1 (K1 h) :*: M1 (K1 t))) -> h : t

    -----

    type Rep0Maybe a = D1 D1Maybe (C1 C1_0Maybe U1
                               :+: C1 C1_1Maybe (S1 NoSelector (Rec0 a)))

    instance Generic (Maybe a) where
        type Rep (Maybe a) = Rep0Maybe a

        from x = M1 (case x of
            Nothing -> L1 (M1 U1)
            Just j  -> R1 (M1 (M1 (K1 j))))

        to (M1 x) = case x of
            L1 (M1 U1)          -> Nothing
            R1 (M1 (M1 (K1 j))) -> Just j

    -----

    type Rep0Ordering = D1 D1Ordering (C1 C1_0Ordering U1
                                  :+: (C1 C1_1Ordering U1 :+: C1 C1_2Ordering U1))

    instance Generic Ordering where
        type Rep Ordering = Rep0Ordering

        from x = M1 (case x of
            LT -> L1 (M1 U1)
            EQ -> R1 (L1 (M1 U1))
            GT -> R1 (R1 (M1 U1)))

        to (M1 x) = case x of
            L1 (M1 U1)      -> LT
            R1 (L1 (M1 U1)) -> EQ
            R1 (R1 (M1 U1)) -> GT

    data D1Ordering
    data C1_0Ordering
    data C1_1Ordering
    data C1_2Ordering

    instance Datatype D1Ordering where
        datatypeName _ = "Ordering"
        moduleName _ = "GHC.Ordering"

    instance Constructor C1_0Ordering where
        conName _ = "LT"

    instance Constructor C1_1Ordering where
        conName _ = "EQ"

    instance Constructor C1_2Ordering where
        conName _ = "GT"

    -----

    type Rep0Unit = D1 D1Unit (C1 C1_0Unit U1)

    instance Generic () where
        type Rep () = Rep0Unit
        from () = M1 (M1 U1)
        to (M1 (M1 U1)) = ()

    data D1Unit
    data C1_0Unit

    instance Datatype D1Unit where
        datatypeName _ = "()"
        moduleName _ = "GHC.Tuple"

    instance Constructor C1_0Unit where
        conName _ = "()"

    -----

    type Rep0Tuple2 a b = D1 D1Tuple2 (C1 C1_0Tuple2 (S1 NoSelector (Rec0 a)
                                                  :*: S1 NoSelector (Rec0 b)))

    instance Generic (a, b) where
        type Rep (a, b) = Rep0Tuple2 a b
        from (a, b) = M1 (M1 (M1 (K1 a) :*: M1 (K1 b)))
        to (M1 (M1 (M1 (K1 a) :*: M1 (K1 b)))) = (a, b)

    -----

    type Rep0Tuple3 a b c = D1 D1Tuple3 (C1 C1_0Tuple3 (S1 NoSelector (Rec0 a)
                                                   :*: (S1 NoSelector (Rec0 b)
                                                   :*:  S1 NoSelector (Rec0 c))))

    instance Generic (a, b, c) where
        type Rep (a, b, c) = Rep0Tuple3 a b c
        from (a, b, c) = M1 (M1 (M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c))))
        to (M1 (M1 (M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c))))) = (a, b, c)

    -----

    type Rep0Tuple4 a b c d = D1 D1Tuple4 (C1 C1_0Tuple4 ((S1 NoSelector (Rec0 a)
                                                      :*:  S1 NoSelector (Rec0 b))
                                                      :*: (S1 NoSelector (Rec0 c)
                                                      :*:  S1 NoSelector (Rec0 d))))

    instance Generic (a, b, c, d) where
        type Rep (a, b, c, d) = Rep0Tuple4 a b c d

        from (a, b, c, d) = M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                                :*: (M1 (K1 c) :*: M1 (K1 d))))

        to (M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                :*: (M1 (K1 c) :*: M1 (K1 d)))))
          = (a, b, c, d)

    -----

    type Rep0Tuple5 a b c d e = D1 D1Tuple5 (C1 C1_0Tuple5 ((S1 NoSelector (Rec0 a)
                                                        :*:  S1 NoSelector (Rec0 b))
                                                        :*: (S1 NoSelector (Rec0 c)
                                                        :*: (S1 NoSelector (Rec0 d)
                                                        :*:  S1 NoSelector (Rec0 e)))))

    instance Generic (a, b, c, d, e) where
        type Rep (a, b, c, d, e) = Rep0Tuple5 a b c d e

        from (a, b, c, d, e) = M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                                   :*: (M1 (K1 c) :*: (M1 (K1 d) :*: M1 (K1 e)))))

        to (M1 (M1 ((M1 (K1 a) :*: M1 (K1 b))
                :*: (M1 (K1 c) :*: (M1 (K1 d) :*: M1 (K1 e))))))
          = (a, b, c, d, e)

    -----

    type Rep0Tuple6 a b c d e f = D1 D1Tuple6 (C1 C1_0Tuple6 ((S1 NoSelector (Rec0 a)
                                                          :*: (S1 NoSelector (Rec0 b)
                                                          :*:  S1 NoSelector (Rec0 c)))
                                                          :*: (S1 NoSelector (Rec0 d)
                                                          :*: (S1 NoSelector (Rec0 e)
                                                          :*:  S1 NoSelector (Rec0 f)))))

    instance Generic (a, b, c, d, e, f) where
        type Rep (a, b, c, d, e, f) = Rep0Tuple6 a b c d e f

        from (a, b, c, d, e, f) = M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                                      :*: (M1 (K1 d) :*: (M1 (K1 e) :*: M1 (K1 f)))))

        to (M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                :*: (M1 (K1 d) :*: (M1 (K1 e) :*: M1 (K1 f))))))
          = (a, b, c, d, e, f)

    -----

    type Rep0Tuple7 a b c d e f g
        = D1 D1Tuple7 (C1 C1_0Tuple7 ((S1 NoSelector (Rec0 a)
                                 :*:  (S1 NoSelector (Rec0 b)
                                 :*:   S1 NoSelector (Rec0 c)))
                                 :*: ((S1 NoSelector (Rec0 d)
                                 :*:   S1 NoSelector (Rec0 e))
                                 :*:  (S1 NoSelector (Rec0 f)
                                 :*:   S1 NoSelector (Rec0 g)))))

    instance Generic (a, b, c, d, e, f, g) where
        type Rep (a, b, c, d, e, f, g) = Rep0Tuple7 a b c d e f g

        from (a, b, c, d, e, f, g) = M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
                         :*: ((M1 (K1 d) :*: M1 (K1 e)) :*: (M1 (K1 f) :*: M1 (K1 g)))))

        to (M1 (M1 ((M1 (K1 a) :*: (M1 (K1 b) :*: M1 (K1 c)))
               :*: ((M1 (K1 d) :*: M1 (K1 e)) :*: (M1 (K1 f) :*: M1 (K1 g))))))
          = (a, b, c, d, e, f, g)

    #endif