Singletons/Tuples.hs:0:0: Splicing declarations
    genSingletons
      [''(), ''(,), ''(,,), ''(,,,), ''(,,,,), ''(,,,,,), ''(,,,,,,)]
  ======>
    Singletons/Tuples.hs:(0,0)-(0,0)
    type Tuple0Sym0 = GHC.Tuple.()
    data instance Sing (z :: GHC.Tuple.())
      = z ~ GHC.Tuple.() => STuple0
    type STuple0 (z :: GHC.Tuple.()) = Sing z
    instance SingKind (KProxy :: KProxy GHC.Tuple.()) where
      type DemoteRep (KProxy :: KProxy GHC.Tuple.()) = GHC.Tuple.()
      fromSing STuple0 = GHC.Tuple.()
      toSing GHC.Tuple.() = SomeSing STuple0
    instance SingI GHC.Tuple.() where
      sing = STuple0
    type Tuple2Sym2 (t :: a) (t :: b) = GHC.Tuple.(,) t t
    instance SuppressUnusedWarnings Tuple2Sym1 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple2Sym1KindInference GHC.Tuple.())
    data Tuple2Sym1 (l :: a) (l :: TyFun b (GHC.Tuple.(,) 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 (GHC.Tuple.(,) a b) -> *))
      = forall arg. KindOf (Apply Tuple2Sym0 arg) ~ KindOf (Tuple2Sym1 arg) =>
        Tuple2Sym0KindInference
    type instance Apply Tuple2Sym0 l = Tuple2Sym1 l
    data instance Sing (z :: GHC.Tuple.(,) a b)
      = forall (n :: a) (n :: b). z ~ GHC.Tuple.(,) n n =>
        STuple2 (Sing n) (Sing n)
    type STuple2 (z :: GHC.Tuple.(,) a b) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b)) =>
             SingKind (KProxy :: KProxy (GHC.Tuple.(,) a b)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,) a b)) = GHC.Tuple.(,) (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 (GHC.Tuple.(,) (n :: a) (n :: b)) where
      sing = STuple2 sing sing
    type Tuple3Sym3 (t :: a) (t :: b) (t :: c) = GHC.Tuple.(,,) t t t
    instance SuppressUnusedWarnings Tuple3Sym2 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) Tuple3Sym2KindInference GHC.Tuple.())
    data Tuple3Sym2 (l :: a)
                    (l :: b)
                    (l :: TyFun c (GHC.Tuple.(,,) 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 (GHC.Tuple.(,,) 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 (GHC.Tuple.(,,) a b c)
                                            -> *)
                                   -> *))
      = forall arg. KindOf (Apply Tuple3Sym0 arg) ~ KindOf (Tuple3Sym1 arg) =>
        Tuple3Sym0KindInference
    type instance Apply Tuple3Sym0 l = Tuple3Sym1 l
    data instance Sing (z :: GHC.Tuple.(,,) a b c)
      = forall (n :: a) (n :: b) (n :: c). z ~ GHC.Tuple.(,,) n n n =>
        STuple3 (Sing n) (Sing n) (Sing n)
    type STuple3 (z :: GHC.Tuple.(,,) a b c) = Sing z
    instance (SingKind (KProxy :: KProxy a),
              SingKind (KProxy :: KProxy b),
              SingKind (KProxy :: KProxy c)) =>
             SingKind (KProxy :: KProxy (GHC.Tuple.(,,) a b c)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,,) a b c)) = GHC.Tuple.(,,) (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 (GHC.Tuple.(,,) (n :: a) (n :: b) (n :: c)) where
      sing = STuple3 sing sing sing
    type Tuple4Sym4 (t :: a) (t :: b) (t :: c) (t :: d) =
        GHC.Tuple.(,,,) 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 (GHC.Tuple.(,,,) 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 (GHC.Tuple.(,,,) 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 (GHC.Tuple.(,,,) 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 (GHC.Tuple.(,,,) 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 :: GHC.Tuple.(,,,) a b c d)
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d). z ~ GHC.Tuple.(,,,) n n n n =>
        STuple4 (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple4 (z :: GHC.Tuple.(,,,) 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 (GHC.Tuple.(,,,) a b c d)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,,,) a b c d)) = GHC.Tuple.(,,,) (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 (GHC.Tuple.(,,,) (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) =
        GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) 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 :: GHC.Tuple.(,,,,) a b c d e)
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d)
               (n :: e). z ~ GHC.Tuple.(,,,,) n n n n n =>
        STuple5 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple5 (z :: GHC.Tuple.(,,,,) 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 (GHC.Tuple.(,,,,) a b c d e)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,,,,) a b c d e)) = GHC.Tuple.(,,,,) (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 (GHC.Tuple.(,,,,) (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) =
        GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) 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 :: GHC.Tuple.(,,,,,) a b c d e f)
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d)
               (n :: e)
               (n :: f). z ~ GHC.Tuple.(,,,,,) n n n n n n =>
        STuple6 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
    type STuple6 (z :: GHC.Tuple.(,,,,,) 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 (GHC.Tuple.(,,,,,) a b c d e f)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,,,,,) a b c d e f)) = GHC.Tuple.(,,,,,) (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 (GHC.Tuple.(,,,,,) (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) =
        GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) 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 :: GHC.Tuple.(,,,,,,) a b c d e f g)
      = forall (n :: a)
               (n :: b)
               (n :: c)
               (n :: d)
               (n :: e)
               (n :: f)
               (n :: g). z ~ GHC.Tuple.(,,,,,,) 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 :: GHC.Tuple.(,,,,,,) 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 (GHC.Tuple.(,,,,,,) a b c d e f g)) where
      type DemoteRep (KProxy :: KProxy (GHC.Tuple.(,,,,,,) a b c d e f g)) = GHC.Tuple.(,,,,,,) (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 (GHC.Tuple.(,,,,,,) (n :: a) (n :: b) (n :: c) (n :: d) (n :: e) (n :: f) (n :: g)) where
      sing = STuple7 sing sing sing sing sing sing sing