type GHC.TypeLits.AppendSymbol :: GHC.Types.Symbol
                                  -> GHC.Types.Symbol -> GHC.Types.Symbol
type family GHC.TypeLits.AppendSymbol a b
type GHC.TypeLits.CharToNat :: Char -> GHC.Num.Natural.Natural
type family GHC.TypeLits.CharToNat a
type GHC.TypeLits.ConsSymbol :: Char
                                -> GHC.Types.Symbol -> GHC.Types.Symbol
type family GHC.TypeLits.ConsSymbol a b
type GHC.TypeLits.KnownChar :: Char -> Constraint
class GHC.TypeLits.KnownChar n where
  GHC.TypeLits.charSing :: GHC.TypeLits.SChar n
  {-# MINIMAL charSing #-}
type GHC.TypeLits.KnownSymbol :: GHC.Types.Symbol -> Constraint
class GHC.TypeLits.KnownSymbol n where
  GHC.TypeLits.symbolSing :: GHC.TypeLits.SSymbol n
  {-# MINIMAL symbolSing #-}
type GHC.TypeLits.NatToChar :: GHC.Num.Natural.Natural -> Char
type family GHC.TypeLits.NatToChar a
pattern GHC.TypeLits.SChar
  :: () => GHC.TypeLits.KnownChar c => GHC.TypeLits.SChar c
type role GHC.TypeLits.SChar phantom
type GHC.TypeLits.SChar :: Char -> *
newtype GHC.TypeLits.SChar s = GHC.TypeLits.UnsafeSChar Char
pattern GHC.TypeLits.SSymbol
  :: () => GHC.TypeLits.KnownSymbol s => GHC.TypeLits.SSymbol s
type role GHC.TypeLits.SSymbol phantom
type GHC.TypeLits.SSymbol :: GHC.Types.Symbol -> *
newtype GHC.TypeLits.SSymbol s = GHC.TypeLits.UnsafeSSymbol String
type GHC.TypeLits.SomeChar :: *
data GHC.TypeLits.SomeChar
  = forall (n :: Char).
    GHC.TypeLits.KnownChar n =>
    GHC.TypeLits.SomeChar (Data.Proxy.Proxy n)
type GHC.TypeLits.SomeSymbol :: *
data GHC.TypeLits.SomeSymbol
  = forall (n :: GHC.Types.Symbol).
    GHC.TypeLits.KnownSymbol n =>
    GHC.TypeLits.SomeSymbol (Data.Proxy.Proxy n)
type GHC.TypeLits.UnconsSymbol :: GHC.Types.Symbol
                                  -> Maybe (Char, GHC.Types.Symbol)
type family GHC.TypeLits.UnconsSymbol a
GHC.TypeLits.charVal :: GHC.TypeLits.KnownChar n => proxy n -> Char
GHC.TypeLits.charVal' ::
  GHC.TypeLits.KnownChar n => GHC.Prim.Proxy# n -> Char
GHC.TypeLits.cmpChar ::
  (GHC.TypeLits.KnownChar a, GHC.TypeLits.KnownChar b) =>
  proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeLits.cmpSymbol ::
  (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
  proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeLits.fromSChar :: GHC.TypeLits.SChar c -> Char
GHC.TypeLits.fromSNat :: GHC.TypeNats.SNat n -> Integer
GHC.TypeLits.fromSSymbol :: GHC.TypeLits.SSymbol s -> String
GHC.TypeLits.natVal ::
  GHC.TypeNats.KnownNat n => proxy n -> Integer
GHC.TypeLits.natVal' ::
  GHC.TypeNats.KnownNat n => GHC.Prim.Proxy# n -> Integer
GHC.TypeLits.sameChar ::
  (GHC.TypeLits.KnownChar a, GHC.TypeLits.KnownChar b) =>
  proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
GHC.TypeLits.sameSymbol ::
  (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
  proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
GHC.TypeLits.someCharVal :: Char -> GHC.TypeLits.SomeChar
GHC.TypeLits.someNatVal :: Integer -> Maybe GHC.TypeNats.SomeNat
GHC.TypeLits.someSymbolVal :: String -> GHC.TypeLits.SomeSymbol
GHC.TypeLits.symbolVal ::
  GHC.TypeLits.KnownSymbol n => proxy n -> String
GHC.TypeLits.symbolVal' ::
  GHC.TypeLits.KnownSymbol n => GHC.Prim.Proxy# n -> String
GHC.TypeLits.withKnownChar ::
  GHC.TypeLits.SChar c -> (GHC.TypeLits.KnownChar c => r) -> r
GHC.TypeLits.withKnownSymbol ::
  GHC.TypeLits.SSymbol s -> (GHC.TypeLits.KnownSymbol s => r) -> r
GHC.TypeLits.withSomeSChar ::
  Char -> (forall (c :: Char). GHC.TypeLits.SChar c -> r) -> r
GHC.TypeLits.withSomeSNat ::
  Integer
  -> (forall (n :: GHC.TypeNats.Nat).
      Maybe (GHC.TypeNats.SNat n) -> r)
  -> r
GHC.TypeLits.withSomeSSymbol ::
  String
  -> (forall (s :: GHC.Types.Symbol). GHC.TypeLits.SSymbol s -> r)
  -> r
type (GHC.TypeNats.*) :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.*) a b
type (GHC.TypeNats.+) :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.+) a b
type (GHC.TypeNats.-) :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.-) a b
type (Data.Type.Ord.<=) :: forall {t}. t -> t -> Constraint
type (Data.Type.Ord.<=) x y =
  GHC.TypeError.Assert
    (x Data.Type.Ord.<=? y) (Data.Type.Ord.LeErrMsg x y)
  :: Constraint
type (Data.Type.Ord.<=?) :: forall k. k -> k -> Bool
type (Data.Type.Ord.<=?) m n =
  Data.Type.Ord.OrdCond
    (Data.Type.Ord.Compare m n) 'True 'True 'False
  :: Bool
type GHC.TypeLits.Internal.CmpChar :: Char -> Char -> Ordering
type family GHC.TypeLits.Internal.CmpChar a b
type GHC.TypeNats.Internal.CmpNat :: GHC.Num.Natural.Natural
                                     -> GHC.Num.Natural.Natural -> Ordering
type family GHC.TypeNats.Internal.CmpNat a b
type GHC.TypeLits.Internal.CmpSymbol :: GHC.Types.Symbol
                                        -> GHC.Types.Symbol -> Ordering
type family GHC.TypeLits.Internal.CmpSymbol a b
type GHC.TypeNats.Div :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family GHC.TypeNats.Div a b
type GHC.TypeError.ErrorMessage :: *
data GHC.TypeError.ErrorMessage
  = GHC.TypeError.Text GHC.Types.Symbol
  | forall t. GHC.TypeError.ShowType t
  | GHC.TypeError.ErrorMessage
    GHC.TypeError.:<>:
    GHC.TypeError.ErrorMessage
  | GHC.TypeError.ErrorMessage
    GHC.TypeError.:$$:
    GHC.TypeError.ErrorMessage
type GHC.TypeNats.KnownNat :: GHC.TypeNats.Nat -> Constraint
class GHC.TypeNats.KnownNat n where
  GHC.TypeNats.natSing :: GHC.TypeNats.SNat n
  {-# MINIMAL natSing #-}
type GHC.TypeNats.Log2 :: GHC.Num.Natural.Natural
                          -> GHC.Num.Natural.Natural
type family GHC.TypeNats.Log2 a
type GHC.TypeNats.Mod :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family GHC.TypeNats.Mod a b
type GHC.TypeNats.Nat :: *
type GHC.TypeNats.Nat = GHC.Num.Natural.Natural
type GHC.Num.Natural.Natural :: *
data GHC.Num.Natural.Natural
  = GHC.Num.Natural.NS GHC.Prim.Word#
  | GHC.Num.Natural.NB GHC.Prim.ByteArray#
type role Data.Type.Ord.OrderingI nominal nominal
type Data.Type.Ord.OrderingI :: forall {k}. k -> k -> *
data Data.Type.Ord.OrderingI a b where
  Data.Type.Ord.LTI :: forall {k} (a :: k) (b :: k).
                       (Data.Type.Ord.Compare a b ~ 'LT) =>
                       Data.Type.Ord.OrderingI a b
  Data.Type.Ord.EQI :: forall {k} (a :: k).
                       (Data.Type.Ord.Compare a a ~ 'EQ) =>
                       Data.Type.Ord.OrderingI a a
  Data.Type.Ord.GTI :: forall {k} (a :: k) (b :: k).
                       (Data.Type.Ord.Compare a b ~ 'GT) =>
                       Data.Type.Ord.OrderingI a b
pattern GHC.TypeNats.SNat
  :: () => GHC.TypeNats.KnownNat n => GHC.TypeNats.SNat n
type role GHC.TypeNats.SNat phantom
type GHC.TypeNats.SNat :: GHC.TypeNats.Nat -> *
newtype GHC.TypeNats.SNat n
  = GHC.TypeNats.UnsafeSNat GHC.Num.Natural.Natural
type GHC.TypeNats.SomeNat :: *
data GHC.TypeNats.SomeNat
  = forall (n :: GHC.TypeNats.Nat).
    GHC.TypeNats.KnownNat n =>
    GHC.TypeNats.SomeNat (Data.Proxy.Proxy n)
type GHC.Types.Symbol :: *
data GHC.Types.Symbol
type GHC.TypeError.TypeError :: forall b.
                                GHC.TypeError.ErrorMessage -> b
type family GHC.TypeError.TypeError a where
type (GHC.TypeNats.^) :: GHC.Num.Natural.Natural
                         -> GHC.Num.Natural.Natural -> GHC.Num.Natural.Natural
type family (GHC.TypeNats.^) a b
GHC.TypeNats.cmpNat ::
  (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) =>
  proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
GHC.TypeNats.sameNat ::
  (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) =>
  proxy1 a -> proxy2 b -> Maybe (a Data.Type.Equality.:~: b)
GHC.TypeNats.withKnownNat ::
  GHC.TypeNats.SNat n -> (GHC.TypeNats.KnownNat n => r) -> r