Singletons/Tuples.hs:0:0: Splicing declarations
    genSingletons
      [''(), ''(,), ''(,,), ''(,,,), ''(,,,,), ''(,,,,,), ''(,,,,,,)]
  ======>
    Singletons/Tuples.hs:(0,0)-(0,0)
    type Tuple0Sym0 = '()
    data instance Sing (z :: ()) = z ~ '() => STuple0
    type STuple0 (z :: ()) = Sing z
    instance SingKind (KProxy :: KProxy ()) where
      type DemoteRep (KProxy :: KProxy ()) = ()
      fromSing STuple0 = GHC.Tuple.()
      toSing GHC.Tuple.() = SomeSing STuple0
    instance SingI '() where
      sing = STuple0
    type Tuple2Sym2 (t :: a) (t :: b) = '(t, t)
    instance SuppressUnusedWarnings Tuple2Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple2Sym1KindInference GHC.Tuple.())
    data Tuple2Sym1 (l :: a) (l :: TyFun b (a, b))
      = forall arg. KindOf (Apply (Tuple2Sym1 l) arg) ~ KindOf (Tuple2Sym2 l arg) =>
        Tuple2Sym1KindInference
    type instance Apply (Tuple2Sym1 l) l = Tuple2Sym2 l l
    instance SuppressUnusedWarnings Tuple2Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple2Sym0KindInference GHC.Tuple.())
    data Tuple2Sym0 (l :: TyFun a (TyFun b (a, b) -> *))
      = forall arg. KindOf (Apply Tuple2Sym0 arg) ~ KindOf (Tuple2Sym1 arg) =>
        Tuple2Sym0KindInference
    type instance Apply Tuple2Sym0 l = Tuple2Sym1 l
    data instance Sing (z :: (a, b))
      = forall (n :: a) (n :: b). z ~ '(n, n) =>
        STuple2 (Sing n) (Sing n)
    type STuple2 (z :: (a, b)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b)) =>
             SingKind (KProxy :: KProxy (a, b)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b))
      fromSing (STuple2 b b) = GHC.Tuple.(,) (fromSing b) (fromSing b)
      toSing (GHC.Tuple.(,) b b)
        = case
              GHC.Tuple.(,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
          of {
            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (STuple2 c c) }
    instance (SingI n, SingI n) => SingI '((n :: a), (n :: b)) where
      sing = STuple2 sing sing
    type Tuple3Sym3 (t :: a) (t :: b) (t :: c) = '(t, t, t)
    instance SuppressUnusedWarnings Tuple3Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple3Sym2KindInference GHC.Tuple.())
    data Tuple3Sym2 (l :: a) (l :: b) (l :: TyFun c (a, b, c))
      = forall arg. KindOf (Apply (Tuple3Sym2 l l) arg) ~ KindOf (Tuple3Sym3 l l arg) =>
        Tuple3Sym2KindInference
    type instance Apply (Tuple3Sym2 l l) l = Tuple3Sym3 l l l
    instance SuppressUnusedWarnings Tuple3Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple3Sym1KindInference GHC.Tuple.())
    data Tuple3Sym1 (l :: a) (l :: TyFun b (TyFun c (a, b, c) -> *))
      = forall arg. KindOf (Apply (Tuple3Sym1 l) arg) ~ KindOf (Tuple3Sym2 l arg) =>
        Tuple3Sym1KindInference
    type instance Apply (Tuple3Sym1 l) l = Tuple3Sym2 l l
    instance SuppressUnusedWarnings Tuple3Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple3Sym0KindInference GHC.Tuple.())
    data Tuple3Sym0 (l :: TyFun a (TyFun b (TyFun c (a, b, c) -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple3Sym0 arg) ~ KindOf (Tuple3Sym1 arg) =>
        Tuple3Sym0KindInference
    type instance Apply Tuple3Sym0 l = Tuple3Sym1 l
    data instance Sing (z :: (a, b, c))
      = forall (n :: a) (n :: b) (n :: c). z ~ '(n, n, n) =>
        STuple3 (Sing n) (Sing n) (Sing n)
    type STuple3 (z :: (a, b, c)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c)) =>
             SingKind (KProxy :: KProxy (a, b, c)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b,
                                        c)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b),
                                               DemoteRep (KProxy :: KProxy c))
      fromSing (STuple3 b b b)
        = GHC.Tuple.(,,) (fromSing b) (fromSing b) (fromSing b)
      toSing (GHC.Tuple.(,,) b b b)
        = case
              GHC.Tuple.(,,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
                (toSing b :: SomeSing (KProxy :: KProxy c))
          of {
            GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing c)
              -> SomeSing (STuple3 c c c) }
    instance (SingI n, SingI n, SingI n) =>
             SingI '((n :: a), (n :: b), (n :: c)) where
      sing = STuple3 sing sing sing
    type Tuple4Sym4 (t :: a) (t :: b) (t :: c) (t :: d) = '(t, t, t, t)
    instance SuppressUnusedWarnings Tuple4Sym3 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple4Sym3KindInference GHC.Tuple.())
    data Tuple4Sym3 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: TyFun d (a, b, c, d))
      = forall arg. KindOf (Apply (Tuple4Sym3 l l l) arg) ~ KindOf (Tuple4Sym4 l l l arg) =>
        Tuple4Sym3KindInference
    type instance Apply (Tuple4Sym3 l l l) l = Tuple4Sym4 l l l l
    instance SuppressUnusedWarnings Tuple4Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple4Sym2KindInference GHC.Tuple.())
    data Tuple4Sym2 (l :: a)
                    (l :: b)
                    (l :: TyFun c (TyFun d (a, b, c, d) -> *))
      = forall arg. KindOf (Apply (Tuple4Sym2 l l) arg) ~ KindOf (Tuple4Sym3 l l arg) =>
        Tuple4Sym2KindInference
    type instance Apply (Tuple4Sym2 l l) l = Tuple4Sym3 l l l
    instance SuppressUnusedWarnings Tuple4Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple4Sym1KindInference GHC.Tuple.())
    data Tuple4Sym1 (l :: a)
                    (l :: TyFun b (TyFun c (TyFun d (a, b, c, d) -> *) -> *))
      = forall arg. KindOf (Apply (Tuple4Sym1 l) arg) ~ KindOf (Tuple4Sym2 l arg) =>
        Tuple4Sym1KindInference
    type instance Apply (Tuple4Sym1 l) l = Tuple4Sym2 l l
    instance SuppressUnusedWarnings Tuple4Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple4Sym0KindInference GHC.Tuple.())
    data Tuple4Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (a,
                                                              b,
                                                              c,
                                                              d)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple4Sym0 arg) ~ KindOf (Tuple4Sym1 arg) =>
        Tuple4Sym0KindInference
    type instance Apply Tuple4Sym0 l = Tuple4Sym1 l
    data instance Sing (z :: (a, b, c, d))
      = forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ '(n, n, n, n) =>
        STuple4 (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple4 (z :: (a, b, c, d)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c),
              SingKind (KProxy :: KProxy d)) =>
             SingKind (KProxy :: KProxy (a, b, c, d)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b,
                                        c,
                                        d)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b),
                                               DemoteRep (KProxy :: KProxy c),
                                               DemoteRep (KProxy :: KProxy d))
      fromSing (STuple4 b b b b)
        = GHC.Tuple.(,,,)
            (fromSing b) (fromSing b) (fromSing b) (fromSing b)
      toSing (GHC.Tuple.(,,,) b b b b)
        = case
              GHC.Tuple.(,,,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
                (toSing b :: SomeSing (KProxy :: KProxy c))
                (toSing b :: SomeSing (KProxy :: KProxy d))
          of {
            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
              -> SomeSing (STuple4 c c c c) }
    instance (SingI n, SingI n, SingI n, SingI n) =>
             SingI '((n :: a), (n :: b), (n :: c), (n :: d)) where
      sing = STuple4 sing sing sing sing
    type Tuple5Sym5 (t :: a) (t :: b) (t :: c) (t :: d) (t :: e) =
        '(t, t, t, t, t)
    instance SuppressUnusedWarnings Tuple5Sym4 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple5Sym4KindInference GHC.Tuple.())
    data Tuple5Sym4 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: TyFun e (a, b, c, d, e))
      = forall arg. KindOf (Apply (Tuple5Sym4 l l l l) arg) ~ KindOf (Tuple5Sym5 l l l l arg) =>
        Tuple5Sym4KindInference
    type instance Apply (Tuple5Sym4 l l l l) l = Tuple5Sym5 l l l l l
    instance SuppressUnusedWarnings Tuple5Sym3 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple5Sym3KindInference GHC.Tuple.())
    data Tuple5Sym3 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: TyFun d (TyFun e (a, b, c, d, e) -> *))
      = forall arg. KindOf (Apply (Tuple5Sym3 l l l) arg) ~ KindOf (Tuple5Sym4 l l l arg) =>
        Tuple5Sym3KindInference
    type instance Apply (Tuple5Sym3 l l l) l = Tuple5Sym4 l l l l
    instance SuppressUnusedWarnings Tuple5Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple5Sym2KindInference GHC.Tuple.())
    data Tuple5Sym2 (l :: a)
                    (l :: b)
                    (l :: TyFun c (TyFun d (TyFun e (a, b, c, d, e) -> *) -> *))
      = forall arg. KindOf (Apply (Tuple5Sym2 l l) arg) ~ KindOf (Tuple5Sym3 l l arg) =>
        Tuple5Sym2KindInference
    type instance Apply (Tuple5Sym2 l l) l = Tuple5Sym3 l l l
    instance SuppressUnusedWarnings Tuple5Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple5Sym1KindInference GHC.Tuple.())
    data Tuple5Sym1 (l :: a)
                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (a, b, c, d, e) -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple5Sym1 l) arg) ~ KindOf (Tuple5Sym2 l arg) =>
        Tuple5Sym1KindInference
    type instance Apply (Tuple5Sym1 l) l = Tuple5Sym2 l l
    instance SuppressUnusedWarnings Tuple5Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple5Sym0KindInference GHC.Tuple.())
    data Tuple5Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (a,
                                                                       b,
                                                                       c,
                                                                       d,
                                                                       e)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple5Sym0 arg) ~ KindOf (Tuple5Sym1 arg) =>
        Tuple5Sym0KindInference
    type instance Apply Tuple5Sym0 l = Tuple5Sym1 l
    data instance Sing (z :: (a, b, c, d, e))
      = forall (n :: a) (n :: b) (n :: c) (n :: d) (n :: e). z ~ '(n,
                                                                   n,
                                                                   n,
                                                                   n,
                                                                   n) =>
        STuple5 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple5 (z :: (a, b, c, d, e)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c),
              SingKind (KProxy :: KProxy d),
              SingKind (KProxy :: KProxy e)) =>
             SingKind (KProxy :: KProxy (a, b, c, d, e)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b,
                                        c,
                                        d,
                                        e)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b),
                                               DemoteRep (KProxy :: KProxy c),
                                               DemoteRep (KProxy :: KProxy d),
                                               DemoteRep (KProxy :: KProxy e))
      fromSing (STuple5 b b b b b)
        = GHC.Tuple.(,,,,)
            (fromSing b) (fromSing b) (fromSing b) (fromSing b) (fromSing b)
      toSing (GHC.Tuple.(,,,,) b b b b b)
        = case
              GHC.Tuple.(,,,,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
                (toSing b :: SomeSing (KProxy :: KProxy c))
                (toSing b :: SomeSing (KProxy :: KProxy d))
                (toSing b :: SomeSing (KProxy :: KProxy e))
          of {
            GHC.Tuple.(,,,,) (SomeSing c)
                             (SomeSing c)
                             (SomeSing c)
                             (SomeSing c)
                             (SomeSing c)
              -> SomeSing (STuple5 c c c c c) }
    instance (SingI n, SingI n, SingI n, SingI n, SingI n) =>
             SingI '((n :: a), (n :: b), (n :: c), (n :: d), (n :: e)) where
      sing = STuple5 sing sing sing sing sing
    type Tuple6Sym6 (t :: a)
                    (t :: b)
                    (t :: c)
                    (t :: d)
                    (t :: e)
                    (t :: f) =
        '(t, t, t, t, t, t)
    instance SuppressUnusedWarnings Tuple6Sym5 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym5KindInference GHC.Tuple.())
    data Tuple6Sym5 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: e)
                    (l :: TyFun f (a, b, c, d, e, f))
      = forall arg. KindOf (Apply (Tuple6Sym5 l l l l l) arg) ~ KindOf (Tuple6Sym6 l l l l l arg) =>
        Tuple6Sym5KindInference
    type instance Apply (Tuple6Sym5 l l l l l) l = Tuple6Sym6 l l l l l l
    instance SuppressUnusedWarnings Tuple6Sym4 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym4KindInference GHC.Tuple.())
    data Tuple6Sym4 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: TyFun e (TyFun f (a, b, c, d, e, f) -> *))
      = forall arg. KindOf (Apply (Tuple6Sym4 l l l l) arg) ~ KindOf (Tuple6Sym5 l l l l arg) =>
        Tuple6Sym4KindInference
    type instance Apply (Tuple6Sym4 l l l l) l = Tuple6Sym5 l l l l l
    instance SuppressUnusedWarnings Tuple6Sym3 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym3KindInference GHC.Tuple.())
    data Tuple6Sym3 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: TyFun d (TyFun e (TyFun f (a, b, c, d, e, f) -> *) -> *))
      = forall arg. KindOf (Apply (Tuple6Sym3 l l l) arg) ~ KindOf (Tuple6Sym4 l l l arg) =>
        Tuple6Sym3KindInference
    type instance Apply (Tuple6Sym3 l l l) l = Tuple6Sym4 l l l l
    instance SuppressUnusedWarnings Tuple6Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym2KindInference GHC.Tuple.())
    data Tuple6Sym2 (l :: a)
                    (l :: b)
                    (l :: TyFun c (TyFun d (TyFun e (TyFun f (a, b, c, d, e, f) -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple6Sym2 l l) arg) ~ KindOf (Tuple6Sym3 l l arg) =>
        Tuple6Sym2KindInference
    type instance Apply (Tuple6Sym2 l l) l = Tuple6Sym3 l l l
    instance SuppressUnusedWarnings Tuple6Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym1KindInference GHC.Tuple.())
    data Tuple6Sym1 (l :: a)
                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (a,
                                                                       b,
                                                                       c,
                                                                       d,
                                                                       e,
                                                                       f)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple6Sym1 l) arg) ~ KindOf (Tuple6Sym2 l arg) =>
        Tuple6Sym1KindInference
    type instance Apply (Tuple6Sym1 l) l = Tuple6Sym2 l l
    instance SuppressUnusedWarnings Tuple6Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple6Sym0KindInference GHC.Tuple.())
    data Tuple6Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (a,
                                                                                b,
                                                                                c,
                                                                                d,
                                                                                e,
                                                                                f)
                                                                       -> *)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple6Sym0 arg) ~ KindOf (Tuple6Sym1 arg) =>
        Tuple6Sym0KindInference
    type instance Apply Tuple6Sym0 l = Tuple6Sym1 l
    data instance Sing (z :: (a, b, c, d, e, f))
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d)
               (n :: e)
               (n :: f). z ~ '(n, n, n, n, n, n) =>
        STuple6 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple6 (z :: (a, b, c, d, e, f)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c),
              SingKind (KProxy :: KProxy d),
              SingKind (KProxy :: KProxy e),
              SingKind (KProxy :: KProxy f)) =>
             SingKind (KProxy :: KProxy (a, b, c, d, e, f)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b,
                                        c,
                                        d,
                                        e,
                                        f)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b),
                                               DemoteRep (KProxy :: KProxy c),
                                               DemoteRep (KProxy :: KProxy d),
                                               DemoteRep (KProxy :: KProxy e),
                                               DemoteRep (KProxy :: KProxy f))
      fromSing (STuple6 b b b b b b)
        = GHC.Tuple.(,,,,,)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
      toSing (GHC.Tuple.(,,,,,) b b b b b b)
        = case
              GHC.Tuple.(,,,,,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
                (toSing b :: SomeSing (KProxy :: KProxy c))
                (toSing b :: SomeSing (KProxy :: KProxy d))
                (toSing b :: SomeSing (KProxy :: KProxy e))
                (toSing b :: SomeSing (KProxy :: KProxy f))
          of {
            GHC.Tuple.(,,,,,) (SomeSing c)
                              (SomeSing c)
                              (SomeSing c)
                              (SomeSing c)
                              (SomeSing c)
                              (SomeSing c)
              -> SomeSing (STuple6 c c c c c c) }
    instance (SingI n, SingI n, SingI n, SingI n, SingI n, SingI n) =>
             SingI '((n :: a),
                     (n :: b),
                     (n :: c),
                     (n :: d),
                     (n :: e),
                     (n :: f)) where
      sing = STuple6 sing sing sing sing sing sing
    type Tuple7Sym7 (t :: a)
                    (t :: b)
                    (t :: c)
                    (t :: d)
                    (t :: e)
                    (t :: f)
                    (t :: g) =
        '(t, t, t, t, t, t, t)
    instance SuppressUnusedWarnings Tuple7Sym6 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym6KindInference GHC.Tuple.())
    data Tuple7Sym6 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: e)
                    (l :: f)
                    (l :: TyFun g (a, b, c, d, e, f, g))
      = forall arg. KindOf (Apply (Tuple7Sym6 l l l l l l) arg) ~ KindOf (Tuple7Sym7 l l l l l l arg) =>
        Tuple7Sym6KindInference
    type instance Apply (Tuple7Sym6 l l l l l l) l = Tuple7Sym7 l l l l l l l
    instance SuppressUnusedWarnings Tuple7Sym5 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym5KindInference GHC.Tuple.())
    data Tuple7Sym5 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: e)
                    (l :: TyFun f (TyFun g (a, b, c, d, e, f, g) -> *))
      = forall arg. KindOf (Apply (Tuple7Sym5 l l l l l) arg) ~ KindOf (Tuple7Sym6 l l l l l arg) =>
        Tuple7Sym5KindInference
    type instance Apply (Tuple7Sym5 l l l l l) l = Tuple7Sym6 l l l l l l
    instance SuppressUnusedWarnings Tuple7Sym4 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym4KindInference GHC.Tuple.())
    data Tuple7Sym4 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: d)
                    (l :: TyFun e (TyFun f (TyFun g (a, b, c, d, e, f, g) -> *) -> *))
      = forall arg. KindOf (Apply (Tuple7Sym4 l l l l) arg) ~ KindOf (Tuple7Sym5 l l l l arg) =>
        Tuple7Sym4KindInference
    type instance Apply (Tuple7Sym4 l l l l) l = Tuple7Sym5 l l l l l
    instance SuppressUnusedWarnings Tuple7Sym3 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym3KindInference GHC.Tuple.())
    data Tuple7Sym3 (l :: a)
                    (l :: b)
                    (l :: c)
                    (l :: TyFun d (TyFun e (TyFun f (TyFun g (a, b, c, d, e, f, g)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple7Sym3 l l l) arg) ~ KindOf (Tuple7Sym4 l l l arg) =>
        Tuple7Sym3KindInference
    type instance Apply (Tuple7Sym3 l l l) l = Tuple7Sym4 l l l l
    instance SuppressUnusedWarnings Tuple7Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym2KindInference GHC.Tuple.())
    data Tuple7Sym2 (l :: a)
                    (l :: b)
                    (l :: TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
                                                                       b,
                                                                       c,
                                                                       d,
                                                                       e,
                                                                       f,
                                                                       g)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple7Sym2 l l) arg) ~ KindOf (Tuple7Sym3 l l arg) =>
        Tuple7Sym2KindInference
    type instance Apply (Tuple7Sym2 l l) l = Tuple7Sym3 l l l
    instance SuppressUnusedWarnings Tuple7Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym1KindInference GHC.Tuple.())
    data Tuple7Sym1 (l :: a)
                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
                                                                                b,
                                                                                c,
                                                                                d,
                                                                                e,
                                                                                f,
                                                                                g)
                                                                       -> *)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply (Tuple7Sym1 l) arg) ~ KindOf (Tuple7Sym2 l arg) =>
        Tuple7Sym1KindInference
    type instance Apply (Tuple7Sym1 l) l = Tuple7Sym2 l l
    instance SuppressUnusedWarnings Tuple7Sym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple7Sym0KindInference GHC.Tuple.())
    data Tuple7Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
                                                                                         b,
                                                                                         c,
                                                                                         d,
                                                                                         e,
                                                                                         f,
                                                                                         g)
                                                                                -> *)
                                                                       -> *)
                                                              -> *)
                                                     -> *)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple7Sym0 arg) ~ KindOf (Tuple7Sym1 arg) =>
        Tuple7Sym0KindInference
    type instance Apply Tuple7Sym0 l = Tuple7Sym1 l
    data instance Sing (z :: (a, b, c, d, e, f, g))
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d)
               (n :: e)
               (n :: f)
               (n :: g). z ~ '(n, n, n, n, n, n, n) =>
        STuple7 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple7 (z :: (a, b, c, d, e, f, g)) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c),
              SingKind (KProxy :: KProxy d),
              SingKind (KProxy :: KProxy e),
              SingKind (KProxy :: KProxy f),
              SingKind (KProxy :: KProxy g)) =>
             SingKind (KProxy :: KProxy (a, b, c, d, e, f, g)) where
      type DemoteRep (KProxy :: KProxy (a,
                                        b,
                                        c,
                                        d,
                                        e,
                                        f,
                                        g)) = (DemoteRep (KProxy :: KProxy a),
                                               DemoteRep (KProxy :: KProxy b),
                                               DemoteRep (KProxy :: KProxy c),
                                               DemoteRep (KProxy :: KProxy d),
                                               DemoteRep (KProxy :: KProxy e),
                                               DemoteRep (KProxy :: KProxy f),
                                               DemoteRep (KProxy :: KProxy g))
      fromSing (STuple7 b b b b b b b)
        = GHC.Tuple.(,,,,,,)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
            (fromSing b)
      toSing (GHC.Tuple.(,,,,,,) b b b b b b b)
        = case
              GHC.Tuple.(,,,,,,)
                (toSing b :: SomeSing (KProxy :: KProxy a))
                (toSing b :: SomeSing (KProxy :: KProxy b))
                (toSing b :: SomeSing (KProxy :: KProxy c))
                (toSing b :: SomeSing (KProxy :: KProxy d))
                (toSing b :: SomeSing (KProxy :: KProxy e))
                (toSing b :: SomeSing (KProxy :: KProxy f))
                (toSing b :: SomeSing (KProxy :: KProxy g))
          of {
            GHC.Tuple.(,,,,,,) (SomeSing c)
                               (SomeSing c)
                               (SomeSing c)
                               (SomeSing c)
                               (SomeSing c)
                               (SomeSing c)
                               (SomeSing c)
              -> SomeSing (STuple7 c c c c c c c) }
    instance (SingI n,
              SingI n,
              SingI n,
              SingI n,
              SingI n,
              SingI n,
              SingI n) =>
             SingI '((n :: a),
                     (n :: b),
                     (n :: c),
                     (n :: d),
                     (n :: e),
                     (n :: f),
                     (n :: g)) where
      sing = STuple7 sing sing sing sing sing sing sing