{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE ConstraintKinds #-}

module Data.Char.Alpha where

import Control.Applicative((<|>))
import Control.Category(id, (.))
import Control.Lens(Prism', Iso', prism', iso, from, involuted, (^.), ( # ))
import Data.Char(Char)
import Data.Eq(Eq)
import Data.Functor((<$), (<$>))
import Data.List(lookup)
import Data.List.NonEmpty(NonEmpty((:|)))
import Data.Maybe(Maybe(Just, Nothing), fromMaybe)
import Data.Ord(Ord)
import GHC.Generics(Generic)
import Text.Parser.Char(CharParsing, char)
import Text.Parser.Combinators((<?>))
import Prelude(Show)

data A_a =
  A_a
  deriving (A_a -> A_a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: A_a -> A_a -> Bool
$c/= :: A_a -> A_a -> Bool
== :: A_a -> A_a -> Bool
$c== :: A_a -> A_a -> Bool
Eq, Eq A_a
A_a -> A_a -> Bool
A_a -> A_a -> Ordering
A_a -> A_a -> A_a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: A_a -> A_a -> A_a
$cmin :: A_a -> A_a -> A_a
max :: A_a -> A_a -> A_a
$cmax :: A_a -> A_a -> A_a
>= :: A_a -> A_a -> Bool
$c>= :: A_a -> A_a -> Bool
> :: A_a -> A_a -> Bool
$c> :: A_a -> A_a -> Bool
<= :: A_a -> A_a -> Bool
$c<= :: A_a -> A_a -> Bool
< :: A_a -> A_a -> Bool
$c< :: A_a -> A_a -> Bool
compare :: A_a -> A_a -> Ordering
$ccompare :: A_a -> A_a -> Ordering
Ord, Int -> A_a -> ShowS
[A_a] -> ShowS
A_a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [A_a] -> ShowS
$cshowList :: [A_a] -> ShowS
show :: A_a -> String
$cshow :: A_a -> String
showsPrec :: Int -> A_a -> ShowS
$cshowsPrec :: Int -> A_a -> ShowS
Show, forall x. Rep A_a x -> A_a
forall x. A_a -> Rep A_a x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep A_a x -> A_a
$cfrom :: forall x. A_a -> Rep A_a x
Generic)

class Ca x where
  _a' ::
    Prism' x ()
  _a ::
    x
  _a =
    forall x. Ca x => Prism' x ()
_a' forall t b. AReview t b -> b -> t
# ()

instance Ca () where
  _a' :: Prism' () ()
_a' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ca A_a where
  _a' :: Prism' A_a ()
_a' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> A_a
A_a)
      (\A_a
A_a -> forall a. a -> Maybe a
Just ())

instance Ca Char where
  _a' :: Prism' Char ()
_a' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'a')
      (\Char
c ->  case Char
c of
                Char
'a' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_a ::
  (Ca x, CharParsing p) =>
  p x
parse_a :: forall x (p :: * -> *). (Ca x, CharParsing p) => p x
parse_a =
  forall x. Ca x => x
_a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'a' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"a"

data B_b =
  B_b
  deriving (B_b -> B_b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: B_b -> B_b -> Bool
$c/= :: B_b -> B_b -> Bool
== :: B_b -> B_b -> Bool
$c== :: B_b -> B_b -> Bool
Eq, Eq B_b
B_b -> B_b -> Bool
B_b -> B_b -> Ordering
B_b -> B_b -> B_b
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: B_b -> B_b -> B_b
$cmin :: B_b -> B_b -> B_b
max :: B_b -> B_b -> B_b
$cmax :: B_b -> B_b -> B_b
>= :: B_b -> B_b -> Bool
$c>= :: B_b -> B_b -> Bool
> :: B_b -> B_b -> Bool
$c> :: B_b -> B_b -> Bool
<= :: B_b -> B_b -> Bool
$c<= :: B_b -> B_b -> Bool
< :: B_b -> B_b -> Bool
$c< :: B_b -> B_b -> Bool
compare :: B_b -> B_b -> Ordering
$ccompare :: B_b -> B_b -> Ordering
Ord, Int -> B_b -> ShowS
[B_b] -> ShowS
B_b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [B_b] -> ShowS
$cshowList :: [B_b] -> ShowS
show :: B_b -> String
$cshow :: B_b -> String
showsPrec :: Int -> B_b -> ShowS
$cshowsPrec :: Int -> B_b -> ShowS
Show, forall x. Rep B_b x -> B_b
forall x. B_b -> Rep B_b x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep B_b x -> B_b
$cfrom :: forall x. B_b -> Rep B_b x
Generic)

class Cb x where
  _b' ::
    Prism' x ()
  _b ::
    x
  _b =
    forall x. Cb x => Prism' x ()
_b' forall t b. AReview t b -> b -> t
# ()

instance Cb () where
  _b' :: Prism' () ()
_b' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cb B_b where
  _b' :: Prism' B_b ()
_b' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> B_b
B_b)
      (\B_b
B_b -> forall a. a -> Maybe a
Just ())

instance Cb Char where
  _b' :: Prism' Char ()
_b' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'b')
      (\Char
c ->  case Char
c of
                Char
'b' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_b ::
  (Cb x, CharParsing p) =>
  p x
parse_b :: forall x (p :: * -> *). (Cb x, CharParsing p) => p x
parse_b =
  forall x. Cb x => x
_b forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'b' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"b"

data C_c =
  C_c
  deriving (C_c -> C_c -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: C_c -> C_c -> Bool
$c/= :: C_c -> C_c -> Bool
== :: C_c -> C_c -> Bool
$c== :: C_c -> C_c -> Bool
Eq, Eq C_c
C_c -> C_c -> Bool
C_c -> C_c -> Ordering
C_c -> C_c -> C_c
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: C_c -> C_c -> C_c
$cmin :: C_c -> C_c -> C_c
max :: C_c -> C_c -> C_c
$cmax :: C_c -> C_c -> C_c
>= :: C_c -> C_c -> Bool
$c>= :: C_c -> C_c -> Bool
> :: C_c -> C_c -> Bool
$c> :: C_c -> C_c -> Bool
<= :: C_c -> C_c -> Bool
$c<= :: C_c -> C_c -> Bool
< :: C_c -> C_c -> Bool
$c< :: C_c -> C_c -> Bool
compare :: C_c -> C_c -> Ordering
$ccompare :: C_c -> C_c -> Ordering
Ord, Int -> C_c -> ShowS
[C_c] -> ShowS
C_c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [C_c] -> ShowS
$cshowList :: [C_c] -> ShowS
show :: C_c -> String
$cshow :: C_c -> String
showsPrec :: Int -> C_c -> ShowS
$cshowsPrec :: Int -> C_c -> ShowS
Show, forall x. Rep C_c x -> C_c
forall x. C_c -> Rep C_c x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep C_c x -> C_c
$cfrom :: forall x. C_c -> Rep C_c x
Generic)

class Cc x where
  _c' ::
    Prism' x ()
  _c ::
    x
  _c =
    forall x. Cc x => Prism' x ()
_c' forall t b. AReview t b -> b -> t
# ()

instance Cc () where
  _c' :: Prism' () ()
_c' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cc C_c where
  _c' :: Prism' C_c ()
_c' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> C_c
C_c)
      (\C_c
C_c -> forall a. a -> Maybe a
Just ())

instance Cc Char where
  _c' :: Prism' Char ()
_c' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'c')
      (\Char
c ->  case Char
c of
                Char
'c' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_c ::
  (Cc x, CharParsing p) =>
  p x
parse_c :: forall x (p :: * -> *). (Cc x, CharParsing p) => p x
parse_c =
  forall x. Cc x => x
_c forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'c' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"c"

data D_d =
  D_d
  deriving (D_d -> D_d -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: D_d -> D_d -> Bool
$c/= :: D_d -> D_d -> Bool
== :: D_d -> D_d -> Bool
$c== :: D_d -> D_d -> Bool
Eq, Eq D_d
D_d -> D_d -> Bool
D_d -> D_d -> Ordering
D_d -> D_d -> D_d
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: D_d -> D_d -> D_d
$cmin :: D_d -> D_d -> D_d
max :: D_d -> D_d -> D_d
$cmax :: D_d -> D_d -> D_d
>= :: D_d -> D_d -> Bool
$c>= :: D_d -> D_d -> Bool
> :: D_d -> D_d -> Bool
$c> :: D_d -> D_d -> Bool
<= :: D_d -> D_d -> Bool
$c<= :: D_d -> D_d -> Bool
< :: D_d -> D_d -> Bool
$c< :: D_d -> D_d -> Bool
compare :: D_d -> D_d -> Ordering
$ccompare :: D_d -> D_d -> Ordering
Ord, Int -> D_d -> ShowS
[D_d] -> ShowS
D_d -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [D_d] -> ShowS
$cshowList :: [D_d] -> ShowS
show :: D_d -> String
$cshow :: D_d -> String
showsPrec :: Int -> D_d -> ShowS
$cshowsPrec :: Int -> D_d -> ShowS
Show, forall x. Rep D_d x -> D_d
forall x. D_d -> Rep D_d x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep D_d x -> D_d
$cfrom :: forall x. D_d -> Rep D_d x
Generic)

class Cd x where
  _d' ::
    Prism' x ()
  _d ::
    x
  _d =
    forall x. Cd x => Prism' x ()
_d' forall t b. AReview t b -> b -> t
# ()

instance Cd () where
  _d' :: Prism' () ()
_d' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cd D_d where
  _d' :: Prism' D_d ()
_d' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> D_d
D_d)
      (\D_d
D_d -> forall a. a -> Maybe a
Just ())

instance Cd Char where
  _d' :: Prism' Char ()
_d' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'd')
      (\Char
c ->  case Char
c of
                Char
'd' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_d ::
  (Cd x, CharParsing p) =>
  p x
parse_d :: forall x (p :: * -> *). (Cd x, CharParsing p) => p x
parse_d =
  forall x. Cd x => x
_d forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'd' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"d"

data E_e =
  E_e
  deriving (E_e -> E_e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: E_e -> E_e -> Bool
$c/= :: E_e -> E_e -> Bool
== :: E_e -> E_e -> Bool
$c== :: E_e -> E_e -> Bool
Eq, Eq E_e
E_e -> E_e -> Bool
E_e -> E_e -> Ordering
E_e -> E_e -> E_e
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: E_e -> E_e -> E_e
$cmin :: E_e -> E_e -> E_e
max :: E_e -> E_e -> E_e
$cmax :: E_e -> E_e -> E_e
>= :: E_e -> E_e -> Bool
$c>= :: E_e -> E_e -> Bool
> :: E_e -> E_e -> Bool
$c> :: E_e -> E_e -> Bool
<= :: E_e -> E_e -> Bool
$c<= :: E_e -> E_e -> Bool
< :: E_e -> E_e -> Bool
$c< :: E_e -> E_e -> Bool
compare :: E_e -> E_e -> Ordering
$ccompare :: E_e -> E_e -> Ordering
Ord, Int -> E_e -> ShowS
[E_e] -> ShowS
E_e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [E_e] -> ShowS
$cshowList :: [E_e] -> ShowS
show :: E_e -> String
$cshow :: E_e -> String
showsPrec :: Int -> E_e -> ShowS
$cshowsPrec :: Int -> E_e -> ShowS
Show, forall x. Rep E_e x -> E_e
forall x. E_e -> Rep E_e x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep E_e x -> E_e
$cfrom :: forall x. E_e -> Rep E_e x
Generic)

class Ce x where
  _e' ::
    Prism' x ()
  _e ::
    x
  _e =
    forall x. Ce x => Prism' x ()
_e' forall t b. AReview t b -> b -> t
# ()

instance Ce () where
  _e' :: Prism' () ()
_e' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ce E_e where
  _e' :: Prism' E_e ()
_e' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> E_e
E_e)
      (\E_e
E_e -> forall a. a -> Maybe a
Just ())

instance Ce Char where
  _e' :: Prism' Char ()
_e' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'e')
      (\Char
c ->  case Char
c of
                Char
'e' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_e ::
  (Ce x, CharParsing p) =>
  p x
parse_e :: forall x (p :: * -> *). (Ce x, CharParsing p) => p x
parse_e =
  forall x. Ce x => x
_e forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'e' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"e"

data F_f =
  F_f
  deriving (F_f -> F_f -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: F_f -> F_f -> Bool
$c/= :: F_f -> F_f -> Bool
== :: F_f -> F_f -> Bool
$c== :: F_f -> F_f -> Bool
Eq, Eq F_f
F_f -> F_f -> Bool
F_f -> F_f -> Ordering
F_f -> F_f -> F_f
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: F_f -> F_f -> F_f
$cmin :: F_f -> F_f -> F_f
max :: F_f -> F_f -> F_f
$cmax :: F_f -> F_f -> F_f
>= :: F_f -> F_f -> Bool
$c>= :: F_f -> F_f -> Bool
> :: F_f -> F_f -> Bool
$c> :: F_f -> F_f -> Bool
<= :: F_f -> F_f -> Bool
$c<= :: F_f -> F_f -> Bool
< :: F_f -> F_f -> Bool
$c< :: F_f -> F_f -> Bool
compare :: F_f -> F_f -> Ordering
$ccompare :: F_f -> F_f -> Ordering
Ord, Int -> F_f -> ShowS
[F_f] -> ShowS
F_f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [F_f] -> ShowS
$cshowList :: [F_f] -> ShowS
show :: F_f -> String
$cshow :: F_f -> String
showsPrec :: Int -> F_f -> ShowS
$cshowsPrec :: Int -> F_f -> ShowS
Show, forall x. Rep F_f x -> F_f
forall x. F_f -> Rep F_f x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep F_f x -> F_f
$cfrom :: forall x. F_f -> Rep F_f x
Generic)

class Cf x where
  _f' ::
    Prism' x ()
  _f ::
    x
  _f =
    forall x. Cf x => Prism' x ()
_f' forall t b. AReview t b -> b -> t
# ()

instance Cf () where
  _f' :: Prism' () ()
_f' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cf F_f where
  _f' :: Prism' F_f ()
_f' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> F_f
F_f)
      (\F_f
F_f -> forall a. a -> Maybe a
Just ())

instance Cf Char where
  _f' :: Prism' Char ()
_f' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'f')
      (\Char
c ->  case Char
c of
                Char
'f' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_f ::
  (Cf x, CharParsing p) =>
  p x
parse_f :: forall x (p :: * -> *). (Cf x, CharParsing p) => p x
parse_f =
  forall x. Cf x => x
_f forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'f' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"f"

data G_g =
  G_g
  deriving (G_g -> G_g -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: G_g -> G_g -> Bool
$c/= :: G_g -> G_g -> Bool
== :: G_g -> G_g -> Bool
$c== :: G_g -> G_g -> Bool
Eq, Eq G_g
G_g -> G_g -> Bool
G_g -> G_g -> Ordering
G_g -> G_g -> G_g
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: G_g -> G_g -> G_g
$cmin :: G_g -> G_g -> G_g
max :: G_g -> G_g -> G_g
$cmax :: G_g -> G_g -> G_g
>= :: G_g -> G_g -> Bool
$c>= :: G_g -> G_g -> Bool
> :: G_g -> G_g -> Bool
$c> :: G_g -> G_g -> Bool
<= :: G_g -> G_g -> Bool
$c<= :: G_g -> G_g -> Bool
< :: G_g -> G_g -> Bool
$c< :: G_g -> G_g -> Bool
compare :: G_g -> G_g -> Ordering
$ccompare :: G_g -> G_g -> Ordering
Ord, Int -> G_g -> ShowS
[G_g] -> ShowS
G_g -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [G_g] -> ShowS
$cshowList :: [G_g] -> ShowS
show :: G_g -> String
$cshow :: G_g -> String
showsPrec :: Int -> G_g -> ShowS
$cshowsPrec :: Int -> G_g -> ShowS
Show, forall x. Rep G_g x -> G_g
forall x. G_g -> Rep G_g x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep G_g x -> G_g
$cfrom :: forall x. G_g -> Rep G_g x
Generic)

class Cg x where
  _g' ::
    Prism' x ()
  _g ::
    x
  _g =
    forall x. Cg x => Prism' x ()
_g' forall t b. AReview t b -> b -> t
# ()

instance Cg () where
  _g' :: Prism' () ()
_g' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cg G_g where
  _g' :: Prism' G_g ()
_g' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> G_g
G_g)
      (\G_g
G_g -> forall a. a -> Maybe a
Just ())

instance Cg Char where
  _g' :: Prism' Char ()
_g' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'g')
      (\Char
c ->  case Char
c of
                Char
'g' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_g ::
  (Cg x, CharParsing p) =>
  p x
parse_g :: forall x (p :: * -> *). (Cg x, CharParsing p) => p x
parse_g =
  forall x. Cg x => x
_g forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'g' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"g"

data H_h =
  H_h
  deriving (H_h -> H_h -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: H_h -> H_h -> Bool
$c/= :: H_h -> H_h -> Bool
== :: H_h -> H_h -> Bool
$c== :: H_h -> H_h -> Bool
Eq, Eq H_h
H_h -> H_h -> Bool
H_h -> H_h -> Ordering
H_h -> H_h -> H_h
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: H_h -> H_h -> H_h
$cmin :: H_h -> H_h -> H_h
max :: H_h -> H_h -> H_h
$cmax :: H_h -> H_h -> H_h
>= :: H_h -> H_h -> Bool
$c>= :: H_h -> H_h -> Bool
> :: H_h -> H_h -> Bool
$c> :: H_h -> H_h -> Bool
<= :: H_h -> H_h -> Bool
$c<= :: H_h -> H_h -> Bool
< :: H_h -> H_h -> Bool
$c< :: H_h -> H_h -> Bool
compare :: H_h -> H_h -> Ordering
$ccompare :: H_h -> H_h -> Ordering
Ord, Int -> H_h -> ShowS
[H_h] -> ShowS
H_h -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [H_h] -> ShowS
$cshowList :: [H_h] -> ShowS
show :: H_h -> String
$cshow :: H_h -> String
showsPrec :: Int -> H_h -> ShowS
$cshowsPrec :: Int -> H_h -> ShowS
Show, forall x. Rep H_h x -> H_h
forall x. H_h -> Rep H_h x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep H_h x -> H_h
$cfrom :: forall x. H_h -> Rep H_h x
Generic)

class Ch x where
  _h' ::
    Prism' x ()
  _h ::
    x
  _h =
    forall x. Ch x => Prism' x ()
_h' forall t b. AReview t b -> b -> t
# ()

instance Ch () where
  _h' :: Prism' () ()
_h' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ch H_h where
  _h' :: Prism' H_h ()
_h' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> H_h
H_h)
      (\H_h
H_h -> forall a. a -> Maybe a
Just ())

instance Ch Char where
  _h' :: Prism' Char ()
_h' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'h')
      (\Char
c ->  case Char
c of
                Char
'h' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_h ::
  (Ch x, CharParsing p) =>
  p x
parse_h :: forall x (p :: * -> *). (Ch x, CharParsing p) => p x
parse_h =
  forall x. Ch x => x
_h forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'h' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"h"

data I_i =
  I_i
  deriving (I_i -> I_i -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: I_i -> I_i -> Bool
$c/= :: I_i -> I_i -> Bool
== :: I_i -> I_i -> Bool
$c== :: I_i -> I_i -> Bool
Eq, Eq I_i
I_i -> I_i -> Bool
I_i -> I_i -> Ordering
I_i -> I_i -> I_i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: I_i -> I_i -> I_i
$cmin :: I_i -> I_i -> I_i
max :: I_i -> I_i -> I_i
$cmax :: I_i -> I_i -> I_i
>= :: I_i -> I_i -> Bool
$c>= :: I_i -> I_i -> Bool
> :: I_i -> I_i -> Bool
$c> :: I_i -> I_i -> Bool
<= :: I_i -> I_i -> Bool
$c<= :: I_i -> I_i -> Bool
< :: I_i -> I_i -> Bool
$c< :: I_i -> I_i -> Bool
compare :: I_i -> I_i -> Ordering
$ccompare :: I_i -> I_i -> Ordering
Ord, Int -> I_i -> ShowS
[I_i] -> ShowS
I_i -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [I_i] -> ShowS
$cshowList :: [I_i] -> ShowS
show :: I_i -> String
$cshow :: I_i -> String
showsPrec :: Int -> I_i -> ShowS
$cshowsPrec :: Int -> I_i -> ShowS
Show, forall x. Rep I_i x -> I_i
forall x. I_i -> Rep I_i x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep I_i x -> I_i
$cfrom :: forall x. I_i -> Rep I_i x
Generic)

class Ci x where
  _i' ::
    Prism' x ()
  _i ::
    x
  _i =
    forall x. Ci x => Prism' x ()
_i' forall t b. AReview t b -> b -> t
# ()

instance Ci () where
  _i' :: Prism' () ()
_i' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ci I_i where
  _i' :: Prism' I_i ()
_i' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> I_i
I_i)
      (\I_i
I_i -> forall a. a -> Maybe a
Just ())

instance Ci Char where
  _i' :: Prism' Char ()
_i' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'i')
      (\Char
c ->  case Char
c of
                Char
'i' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_i ::
  (Ci x, CharParsing p) =>
  p x
parse_i :: forall x (p :: * -> *). (Ci x, CharParsing p) => p x
parse_i =
  forall x. Ci x => x
_i forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'i' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"i"

data J_j =
  J_j
  deriving (J_j -> J_j -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: J_j -> J_j -> Bool
$c/= :: J_j -> J_j -> Bool
== :: J_j -> J_j -> Bool
$c== :: J_j -> J_j -> Bool
Eq, Eq J_j
J_j -> J_j -> Bool
J_j -> J_j -> Ordering
J_j -> J_j -> J_j
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: J_j -> J_j -> J_j
$cmin :: J_j -> J_j -> J_j
max :: J_j -> J_j -> J_j
$cmax :: J_j -> J_j -> J_j
>= :: J_j -> J_j -> Bool
$c>= :: J_j -> J_j -> Bool
> :: J_j -> J_j -> Bool
$c> :: J_j -> J_j -> Bool
<= :: J_j -> J_j -> Bool
$c<= :: J_j -> J_j -> Bool
< :: J_j -> J_j -> Bool
$c< :: J_j -> J_j -> Bool
compare :: J_j -> J_j -> Ordering
$ccompare :: J_j -> J_j -> Ordering
Ord, Int -> J_j -> ShowS
[J_j] -> ShowS
J_j -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [J_j] -> ShowS
$cshowList :: [J_j] -> ShowS
show :: J_j -> String
$cshow :: J_j -> String
showsPrec :: Int -> J_j -> ShowS
$cshowsPrec :: Int -> J_j -> ShowS
Show, forall x. Rep J_j x -> J_j
forall x. J_j -> Rep J_j x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep J_j x -> J_j
$cfrom :: forall x. J_j -> Rep J_j x
Generic)

class Cj x where
  _j' ::
    Prism' x ()
  _j ::
    x
  _j =
    forall x. Cj x => Prism' x ()
_j' forall t b. AReview t b -> b -> t
# ()

instance Cj () where
  _j' :: Prism' () ()
_j' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cj J_j where
  _j' :: Prism' J_j ()
_j' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> J_j
J_j)
      (\J_j
J_j -> forall a. a -> Maybe a
Just ())

instance Cj Char where
  _j' :: Prism' Char ()
_j' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'j')
      (\Char
c ->  case Char
c of
                Char
'j' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_j ::
  (Cj x, CharParsing p) =>
  p x
parse_j :: forall x (p :: * -> *). (Cj x, CharParsing p) => p x
parse_j =
  forall x. Cj x => x
_j forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'j' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"j"

data K_k =
  K_k
  deriving (K_k -> K_k -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: K_k -> K_k -> Bool
$c/= :: K_k -> K_k -> Bool
== :: K_k -> K_k -> Bool
$c== :: K_k -> K_k -> Bool
Eq, Eq K_k
K_k -> K_k -> Bool
K_k -> K_k -> Ordering
K_k -> K_k -> K_k
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: K_k -> K_k -> K_k
$cmin :: K_k -> K_k -> K_k
max :: K_k -> K_k -> K_k
$cmax :: K_k -> K_k -> K_k
>= :: K_k -> K_k -> Bool
$c>= :: K_k -> K_k -> Bool
> :: K_k -> K_k -> Bool
$c> :: K_k -> K_k -> Bool
<= :: K_k -> K_k -> Bool
$c<= :: K_k -> K_k -> Bool
< :: K_k -> K_k -> Bool
$c< :: K_k -> K_k -> Bool
compare :: K_k -> K_k -> Ordering
$ccompare :: K_k -> K_k -> Ordering
Ord, Int -> K_k -> ShowS
[K_k] -> ShowS
K_k -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [K_k] -> ShowS
$cshowList :: [K_k] -> ShowS
show :: K_k -> String
$cshow :: K_k -> String
showsPrec :: Int -> K_k -> ShowS
$cshowsPrec :: Int -> K_k -> ShowS
Show, forall x. Rep K_k x -> K_k
forall x. K_k -> Rep K_k x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep K_k x -> K_k
$cfrom :: forall x. K_k -> Rep K_k x
Generic)

class Ck x where
  _k' ::
    Prism' x ()
  _k ::
    x
  _k =
    forall x. Ck x => Prism' x ()
_k' forall t b. AReview t b -> b -> t
# ()

instance Ck () where
  _k' :: Prism' () ()
_k' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ck K_k where
  _k' :: Prism' K_k ()
_k' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> K_k
K_k)
      (\K_k
K_k -> forall a. a -> Maybe a
Just ())

instance Ck Char where
  _k' :: Prism' Char ()
_k' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'k')
      (\Char
c ->  case Char
c of
                Char
'k' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_k ::
  (Ck x, CharParsing p) =>
  p x
parse_k :: forall x (p :: * -> *). (Ck x, CharParsing p) => p x
parse_k =
  forall x. Ck x => x
_k forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'k' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"k"

data L_l =
  L_l
  deriving (L_l -> L_l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: L_l -> L_l -> Bool
$c/= :: L_l -> L_l -> Bool
== :: L_l -> L_l -> Bool
$c== :: L_l -> L_l -> Bool
Eq, Eq L_l
L_l -> L_l -> Bool
L_l -> L_l -> Ordering
L_l -> L_l -> L_l
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: L_l -> L_l -> L_l
$cmin :: L_l -> L_l -> L_l
max :: L_l -> L_l -> L_l
$cmax :: L_l -> L_l -> L_l
>= :: L_l -> L_l -> Bool
$c>= :: L_l -> L_l -> Bool
> :: L_l -> L_l -> Bool
$c> :: L_l -> L_l -> Bool
<= :: L_l -> L_l -> Bool
$c<= :: L_l -> L_l -> Bool
< :: L_l -> L_l -> Bool
$c< :: L_l -> L_l -> Bool
compare :: L_l -> L_l -> Ordering
$ccompare :: L_l -> L_l -> Ordering
Ord, Int -> L_l -> ShowS
[L_l] -> ShowS
L_l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [L_l] -> ShowS
$cshowList :: [L_l] -> ShowS
show :: L_l -> String
$cshow :: L_l -> String
showsPrec :: Int -> L_l -> ShowS
$cshowsPrec :: Int -> L_l -> ShowS
Show, forall x. Rep L_l x -> L_l
forall x. L_l -> Rep L_l x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep L_l x -> L_l
$cfrom :: forall x. L_l -> Rep L_l x
Generic)

class Cl x where
  _l' ::
    Prism' x ()
  _l ::
    x
  _l =
    forall x. Cl x => Prism' x ()
_l' forall t b. AReview t b -> b -> t
# ()

instance Cl () where
  _l' :: Prism' () ()
_l' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cl L_l where
  _l' :: Prism' L_l ()
_l' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> L_l
L_l)
      (\L_l
L_l -> forall a. a -> Maybe a
Just ())

instance Cl Char where
  _l' :: Prism' Char ()
_l' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'l')
      (\Char
c ->  case Char
c of
                Char
'l' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_l ::
  (Cl x, CharParsing p) =>
  p x
parse_l :: forall x (p :: * -> *). (Cl x, CharParsing p) => p x
parse_l =
  forall x. Cl x => x
_l forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'l' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"l"

data M_m =
  M_m
  deriving (M_m -> M_m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: M_m -> M_m -> Bool
$c/= :: M_m -> M_m -> Bool
== :: M_m -> M_m -> Bool
$c== :: M_m -> M_m -> Bool
Eq, Eq M_m
M_m -> M_m -> Bool
M_m -> M_m -> Ordering
M_m -> M_m -> M_m
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: M_m -> M_m -> M_m
$cmin :: M_m -> M_m -> M_m
max :: M_m -> M_m -> M_m
$cmax :: M_m -> M_m -> M_m
>= :: M_m -> M_m -> Bool
$c>= :: M_m -> M_m -> Bool
> :: M_m -> M_m -> Bool
$c> :: M_m -> M_m -> Bool
<= :: M_m -> M_m -> Bool
$c<= :: M_m -> M_m -> Bool
< :: M_m -> M_m -> Bool
$c< :: M_m -> M_m -> Bool
compare :: M_m -> M_m -> Ordering
$ccompare :: M_m -> M_m -> Ordering
Ord, Int -> M_m -> ShowS
[M_m] -> ShowS
M_m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [M_m] -> ShowS
$cshowList :: [M_m] -> ShowS
show :: M_m -> String
$cshow :: M_m -> String
showsPrec :: Int -> M_m -> ShowS
$cshowsPrec :: Int -> M_m -> ShowS
Show, forall x. Rep M_m x -> M_m
forall x. M_m -> Rep M_m x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep M_m x -> M_m
$cfrom :: forall x. M_m -> Rep M_m x
Generic)

class Cm x where
  _m' ::
    Prism' x ()
  _m ::
    x
  _m =
    forall x. Cm x => Prism' x ()
_m' forall t b. AReview t b -> b -> t
# ()

instance Cm () where
  _m' :: Prism' () ()
_m' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cm M_m where
  _m' :: Prism' M_m ()
_m' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> M_m
M_m)
      (\M_m
M_m -> forall a. a -> Maybe a
Just ())

instance Cm Char where
  _m' :: Prism' Char ()
_m' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'm')
      (\Char
c ->  case Char
c of
                Char
'm' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_m ::
  (Cm x, CharParsing p) =>
  p x
parse_m :: forall x (p :: * -> *). (Cm x, CharParsing p) => p x
parse_m =
  forall x. Cm x => x
_m forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'm' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"m"

data N_n =
  N_n
  deriving (N_n -> N_n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: N_n -> N_n -> Bool
$c/= :: N_n -> N_n -> Bool
== :: N_n -> N_n -> Bool
$c== :: N_n -> N_n -> Bool
Eq, Eq N_n
N_n -> N_n -> Bool
N_n -> N_n -> Ordering
N_n -> N_n -> N_n
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: N_n -> N_n -> N_n
$cmin :: N_n -> N_n -> N_n
max :: N_n -> N_n -> N_n
$cmax :: N_n -> N_n -> N_n
>= :: N_n -> N_n -> Bool
$c>= :: N_n -> N_n -> Bool
> :: N_n -> N_n -> Bool
$c> :: N_n -> N_n -> Bool
<= :: N_n -> N_n -> Bool
$c<= :: N_n -> N_n -> Bool
< :: N_n -> N_n -> Bool
$c< :: N_n -> N_n -> Bool
compare :: N_n -> N_n -> Ordering
$ccompare :: N_n -> N_n -> Ordering
Ord, Int -> N_n -> ShowS
[N_n] -> ShowS
N_n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [N_n] -> ShowS
$cshowList :: [N_n] -> ShowS
show :: N_n -> String
$cshow :: N_n -> String
showsPrec :: Int -> N_n -> ShowS
$cshowsPrec :: Int -> N_n -> ShowS
Show, forall x. Rep N_n x -> N_n
forall x. N_n -> Rep N_n x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep N_n x -> N_n
$cfrom :: forall x. N_n -> Rep N_n x
Generic)

class Cn x where
  _n' ::
    Prism' x ()
  _n ::
    x
  _n =
    forall x. Cn x => Prism' x ()
_n' forall t b. AReview t b -> b -> t
# ()

instance Cn () where
  _n' :: Prism' () ()
_n' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cn N_n where
  _n' :: Prism' N_n ()
_n' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> N_n
N_n)
      (\N_n
N_n -> forall a. a -> Maybe a
Just ())

instance Cn Char where
  _n' :: Prism' Char ()
_n' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'n')
      (\Char
c ->  case Char
c of
                Char
'n' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_n ::
  (Cn x, CharParsing p) =>
  p x
parse_n :: forall x (p :: * -> *). (Cn x, CharParsing p) => p x
parse_n =
  forall x. Cn x => x
_n forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'n' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"n"

data O_o =
  O_o
  deriving (O_o -> O_o -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: O_o -> O_o -> Bool
$c/= :: O_o -> O_o -> Bool
== :: O_o -> O_o -> Bool
$c== :: O_o -> O_o -> Bool
Eq, Eq O_o
O_o -> O_o -> Bool
O_o -> O_o -> Ordering
O_o -> O_o -> O_o
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: O_o -> O_o -> O_o
$cmin :: O_o -> O_o -> O_o
max :: O_o -> O_o -> O_o
$cmax :: O_o -> O_o -> O_o
>= :: O_o -> O_o -> Bool
$c>= :: O_o -> O_o -> Bool
> :: O_o -> O_o -> Bool
$c> :: O_o -> O_o -> Bool
<= :: O_o -> O_o -> Bool
$c<= :: O_o -> O_o -> Bool
< :: O_o -> O_o -> Bool
$c< :: O_o -> O_o -> Bool
compare :: O_o -> O_o -> Ordering
$ccompare :: O_o -> O_o -> Ordering
Ord, Int -> O_o -> ShowS
[O_o] -> ShowS
O_o -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [O_o] -> ShowS
$cshowList :: [O_o] -> ShowS
show :: O_o -> String
$cshow :: O_o -> String
showsPrec :: Int -> O_o -> ShowS
$cshowsPrec :: Int -> O_o -> ShowS
Show, forall x. Rep O_o x -> O_o
forall x. O_o -> Rep O_o x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep O_o x -> O_o
$cfrom :: forall x. O_o -> Rep O_o x
Generic)

class Co x where
  _o' ::
    Prism' x ()
  _o ::
    x
  _o =
    forall x. Co x => Prism' x ()
_o' forall t b. AReview t b -> b -> t
# ()

instance Co () where
  _o' :: Prism' () ()
_o' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Co O_o where
  _o' :: Prism' O_o ()
_o' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> O_o
O_o)
      (\O_o
O_o -> forall a. a -> Maybe a
Just ())

instance Co Char where
  _o' :: Prism' Char ()
_o' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'o')
      (\Char
c ->  case Char
c of
                Char
'o' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_o ::
  (Co x, CharParsing p) =>
  p x
parse_o :: forall x (p :: * -> *). (Co x, CharParsing p) => p x
parse_o =
  forall x. Co x => x
_o forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'o' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"o"

data P_p =
  P_p
  deriving (P_p -> P_p -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: P_p -> P_p -> Bool
$c/= :: P_p -> P_p -> Bool
== :: P_p -> P_p -> Bool
$c== :: P_p -> P_p -> Bool
Eq, Eq P_p
P_p -> P_p -> Bool
P_p -> P_p -> Ordering
P_p -> P_p -> P_p
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: P_p -> P_p -> P_p
$cmin :: P_p -> P_p -> P_p
max :: P_p -> P_p -> P_p
$cmax :: P_p -> P_p -> P_p
>= :: P_p -> P_p -> Bool
$c>= :: P_p -> P_p -> Bool
> :: P_p -> P_p -> Bool
$c> :: P_p -> P_p -> Bool
<= :: P_p -> P_p -> Bool
$c<= :: P_p -> P_p -> Bool
< :: P_p -> P_p -> Bool
$c< :: P_p -> P_p -> Bool
compare :: P_p -> P_p -> Ordering
$ccompare :: P_p -> P_p -> Ordering
Ord, Int -> P_p -> ShowS
[P_p] -> ShowS
P_p -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [P_p] -> ShowS
$cshowList :: [P_p] -> ShowS
show :: P_p -> String
$cshow :: P_p -> String
showsPrec :: Int -> P_p -> ShowS
$cshowsPrec :: Int -> P_p -> ShowS
Show, forall x. Rep P_p x -> P_p
forall x. P_p -> Rep P_p x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep P_p x -> P_p
$cfrom :: forall x. P_p -> Rep P_p x
Generic)

class Cp x where
  _p' ::
    Prism' x ()
  _p ::
    x
  _p =
    forall x. Cp x => Prism' x ()
_p' forall t b. AReview t b -> b -> t
# ()

instance Cp () where
  _p' :: Prism' () ()
_p' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cp P_p where
  _p' :: Prism' P_p ()
_p' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> P_p
P_p)
      (\P_p
P_p -> forall a. a -> Maybe a
Just ())

instance Cp Char where
  _p' :: Prism' Char ()
_p' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'p')
      (\Char
c ->  case Char
c of
                Char
'p' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_p ::
  (Cp x, CharParsing p) =>
  p x
parse_p :: forall x (p :: * -> *). (Cp x, CharParsing p) => p x
parse_p =
  forall x. Cp x => x
_p forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'p' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"p"

data Q_q =
  Q_q
  deriving (Q_q -> Q_q -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Q_q -> Q_q -> Bool
$c/= :: Q_q -> Q_q -> Bool
== :: Q_q -> Q_q -> Bool
$c== :: Q_q -> Q_q -> Bool
Eq, Eq Q_q
Q_q -> Q_q -> Bool
Q_q -> Q_q -> Ordering
Q_q -> Q_q -> Q_q
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Q_q -> Q_q -> Q_q
$cmin :: Q_q -> Q_q -> Q_q
max :: Q_q -> Q_q -> Q_q
$cmax :: Q_q -> Q_q -> Q_q
>= :: Q_q -> Q_q -> Bool
$c>= :: Q_q -> Q_q -> Bool
> :: Q_q -> Q_q -> Bool
$c> :: Q_q -> Q_q -> Bool
<= :: Q_q -> Q_q -> Bool
$c<= :: Q_q -> Q_q -> Bool
< :: Q_q -> Q_q -> Bool
$c< :: Q_q -> Q_q -> Bool
compare :: Q_q -> Q_q -> Ordering
$ccompare :: Q_q -> Q_q -> Ordering
Ord, Int -> Q_q -> ShowS
[Q_q] -> ShowS
Q_q -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Q_q] -> ShowS
$cshowList :: [Q_q] -> ShowS
show :: Q_q -> String
$cshow :: Q_q -> String
showsPrec :: Int -> Q_q -> ShowS
$cshowsPrec :: Int -> Q_q -> ShowS
Show, forall x. Rep Q_q x -> Q_q
forall x. Q_q -> Rep Q_q x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Q_q x -> Q_q
$cfrom :: forall x. Q_q -> Rep Q_q x
Generic)

class Cq x where
  _q' ::
    Prism' x ()
  _q ::
    x
  _q =
    forall x. Cq x => Prism' x ()
_q' forall t b. AReview t b -> b -> t
# ()

instance Cq () where
  _q' :: Prism' () ()
_q' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cq Q_q where
  _q' :: Prism' Q_q ()
_q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Q_q
Q_q)
      (\Q_q
Q_q -> forall a. a -> Maybe a
Just ())

instance Cq Char where
  _q' :: Prism' Char ()
_q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'q')
      (\Char
c ->  case Char
c of
                Char
'q' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_q ::
  (Cq x, CharParsing p) =>
  p x
parse_q :: forall x (p :: * -> *). (Cq x, CharParsing p) => p x
parse_q =
  forall x. Cq x => x
_q forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'q' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"q"

data R_r =
  R_r
  deriving (R_r -> R_r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: R_r -> R_r -> Bool
$c/= :: R_r -> R_r -> Bool
== :: R_r -> R_r -> Bool
$c== :: R_r -> R_r -> Bool
Eq, Eq R_r
R_r -> R_r -> Bool
R_r -> R_r -> Ordering
R_r -> R_r -> R_r
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: R_r -> R_r -> R_r
$cmin :: R_r -> R_r -> R_r
max :: R_r -> R_r -> R_r
$cmax :: R_r -> R_r -> R_r
>= :: R_r -> R_r -> Bool
$c>= :: R_r -> R_r -> Bool
> :: R_r -> R_r -> Bool
$c> :: R_r -> R_r -> Bool
<= :: R_r -> R_r -> Bool
$c<= :: R_r -> R_r -> Bool
< :: R_r -> R_r -> Bool
$c< :: R_r -> R_r -> Bool
compare :: R_r -> R_r -> Ordering
$ccompare :: R_r -> R_r -> Ordering
Ord, Int -> R_r -> ShowS
[R_r] -> ShowS
R_r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [R_r] -> ShowS
$cshowList :: [R_r] -> ShowS
show :: R_r -> String
$cshow :: R_r -> String
showsPrec :: Int -> R_r -> ShowS
$cshowsPrec :: Int -> R_r -> ShowS
Show, forall x. Rep R_r x -> R_r
forall x. R_r -> Rep R_r x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep R_r x -> R_r
$cfrom :: forall x. R_r -> Rep R_r x
Generic)

class Cr x where
  _r' ::
    Prism' x ()
  _r ::
    x
  _r =
    forall x. Cr x => Prism' x ()
_r' forall t b. AReview t b -> b -> t
# ()

instance Cr () where
  _r' :: Prism' () ()
_r' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cr R_r where
  _r' :: Prism' R_r ()
_r' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> R_r
R_r)
      (\R_r
R_r -> forall a. a -> Maybe a
Just ())

instance Cr Char where
  _r' :: Prism' Char ()
_r' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'r')
      (\Char
c ->  case Char
c of
                Char
'r' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_r ::
  (Cr x, CharParsing p) =>
  p x
parse_r :: forall x (p :: * -> *). (Cr x, CharParsing p) => p x
parse_r =
  forall x. Cr x => x
_r forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'r' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"r"

data S_s =
  S_s
  deriving (S_s -> S_s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: S_s -> S_s -> Bool
$c/= :: S_s -> S_s -> Bool
== :: S_s -> S_s -> Bool
$c== :: S_s -> S_s -> Bool
Eq, Eq S_s
S_s -> S_s -> Bool
S_s -> S_s -> Ordering
S_s -> S_s -> S_s
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: S_s -> S_s -> S_s
$cmin :: S_s -> S_s -> S_s
max :: S_s -> S_s -> S_s
$cmax :: S_s -> S_s -> S_s
>= :: S_s -> S_s -> Bool
$c>= :: S_s -> S_s -> Bool
> :: S_s -> S_s -> Bool
$c> :: S_s -> S_s -> Bool
<= :: S_s -> S_s -> Bool
$c<= :: S_s -> S_s -> Bool
< :: S_s -> S_s -> Bool
$c< :: S_s -> S_s -> Bool
compare :: S_s -> S_s -> Ordering
$ccompare :: S_s -> S_s -> Ordering
Ord, Int -> S_s -> ShowS
[S_s] -> ShowS
S_s -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [S_s] -> ShowS
$cshowList :: [S_s] -> ShowS
show :: S_s -> String
$cshow :: S_s -> String
showsPrec :: Int -> S_s -> ShowS
$cshowsPrec :: Int -> S_s -> ShowS
Show, forall x. Rep S_s x -> S_s
forall x. S_s -> Rep S_s x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep S_s x -> S_s
$cfrom :: forall x. S_s -> Rep S_s x
Generic)

class Cs x where
  _s' ::
    Prism' x ()
  _s ::
    x
  _s =
    forall x. Cs x => Prism' x ()
_s' forall t b. AReview t b -> b -> t
# ()

instance Cs () where
  _s' :: Prism' () ()
_s' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cs S_s where
  _s' :: Prism' S_s ()
_s' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> S_s
S_s)
      (\S_s
S_s -> forall a. a -> Maybe a
Just ())

instance Cs Char where
  _s' :: Prism' Char ()
_s' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
's')
      (\Char
c ->  case Char
c of
                Char
's' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_s ::
  (Cs x, CharParsing p) =>
  p x
parse_s :: forall x (p :: * -> *). (Cs x, CharParsing p) => p x
parse_s =
  forall x. Cs x => x
_s forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
's' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"s"

data T_t =
  T_t
  deriving (T_t -> T_t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: T_t -> T_t -> Bool
$c/= :: T_t -> T_t -> Bool
== :: T_t -> T_t -> Bool
$c== :: T_t -> T_t -> Bool
Eq, Eq T_t
T_t -> T_t -> Bool
T_t -> T_t -> Ordering
T_t -> T_t -> T_t
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: T_t -> T_t -> T_t
$cmin :: T_t -> T_t -> T_t
max :: T_t -> T_t -> T_t
$cmax :: T_t -> T_t -> T_t
>= :: T_t -> T_t -> Bool
$c>= :: T_t -> T_t -> Bool
> :: T_t -> T_t -> Bool
$c> :: T_t -> T_t -> Bool
<= :: T_t -> T_t -> Bool
$c<= :: T_t -> T_t -> Bool
< :: T_t -> T_t -> Bool
$c< :: T_t -> T_t -> Bool
compare :: T_t -> T_t -> Ordering
$ccompare :: T_t -> T_t -> Ordering
Ord, Int -> T_t -> ShowS
[T_t] -> ShowS
T_t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [T_t] -> ShowS
$cshowList :: [T_t] -> ShowS
show :: T_t -> String
$cshow :: T_t -> String
showsPrec :: Int -> T_t -> ShowS
$cshowsPrec :: Int -> T_t -> ShowS
Show, forall x. Rep T_t x -> T_t
forall x. T_t -> Rep T_t x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep T_t x -> T_t
$cfrom :: forall x. T_t -> Rep T_t x
Generic)

class Ct x where
  _t' ::
    Prism' x ()
  _t ::
    x
  _t =
    forall x. Ct x => Prism' x ()
_t' forall t b. AReview t b -> b -> t
# ()

instance Ct () where
  _t' :: Prism' () ()
_t' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Ct T_t where
  _t' :: Prism' T_t ()
_t' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> T_t
T_t)
      (\T_t
T_t -> forall a. a -> Maybe a
Just ())

instance Ct Char where
  _t' :: Prism' Char ()
_t' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
't')
      (\Char
c ->  case Char
c of
                Char
't' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_t ::
  (Ct x, CharParsing p) =>
  p x
parse_t :: forall x (p :: * -> *). (Ct x, CharParsing p) => p x
parse_t =
  forall x. Ct x => x
_t forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
't' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"t"

data U_u =
  U_u
  deriving (U_u -> U_u -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: U_u -> U_u -> Bool
$c/= :: U_u -> U_u -> Bool
== :: U_u -> U_u -> Bool
$c== :: U_u -> U_u -> Bool
Eq, Eq U_u
U_u -> U_u -> Bool
U_u -> U_u -> Ordering
U_u -> U_u -> U_u
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: U_u -> U_u -> U_u
$cmin :: U_u -> U_u -> U_u
max :: U_u -> U_u -> U_u
$cmax :: U_u -> U_u -> U_u
>= :: U_u -> U_u -> Bool
$c>= :: U_u -> U_u -> Bool
> :: U_u -> U_u -> Bool
$c> :: U_u -> U_u -> Bool
<= :: U_u -> U_u -> Bool
$c<= :: U_u -> U_u -> Bool
< :: U_u -> U_u -> Bool
$c< :: U_u -> U_u -> Bool
compare :: U_u -> U_u -> Ordering
$ccompare :: U_u -> U_u -> Ordering
Ord, Int -> U_u -> ShowS
[U_u] -> ShowS
U_u -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [U_u] -> ShowS
$cshowList :: [U_u] -> ShowS
show :: U_u -> String
$cshow :: U_u -> String
showsPrec :: Int -> U_u -> ShowS
$cshowsPrec :: Int -> U_u -> ShowS
Show, forall x. Rep U_u x -> U_u
forall x. U_u -> Rep U_u x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep U_u x -> U_u
$cfrom :: forall x. U_u -> Rep U_u x
Generic)

class Cu x where
  _u' ::
    Prism' x ()
  _u ::
    x
  _u =
    forall x. Cu x => Prism' x ()
_u' forall t b. AReview t b -> b -> t
# ()

instance Cu () where
  _u' :: Prism' () ()
_u' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cu U_u where
  _u' :: Prism' U_u ()
_u' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> U_u
U_u)
      (\U_u
U_u -> forall a. a -> Maybe a
Just ())

instance Cu Char where
  _u' :: Prism' Char ()
_u' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'u')
      (\Char
c ->  case Char
c of
                Char
'u' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_u ::
  (Cu x, CharParsing p) =>
  p x
parse_u :: forall x (p :: * -> *). (Cu x, CharParsing p) => p x
parse_u =
  forall x. Cu x => x
_u forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'u' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"u"

data V_v =
  V_v
  deriving (V_v -> V_v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: V_v -> V_v -> Bool
$c/= :: V_v -> V_v -> Bool
== :: V_v -> V_v -> Bool
$c== :: V_v -> V_v -> Bool
Eq, Eq V_v
V_v -> V_v -> Bool
V_v -> V_v -> Ordering
V_v -> V_v -> V_v
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: V_v -> V_v -> V_v
$cmin :: V_v -> V_v -> V_v
max :: V_v -> V_v -> V_v
$cmax :: V_v -> V_v -> V_v
>= :: V_v -> V_v -> Bool
$c>= :: V_v -> V_v -> Bool
> :: V_v -> V_v -> Bool
$c> :: V_v -> V_v -> Bool
<= :: V_v -> V_v -> Bool
$c<= :: V_v -> V_v -> Bool
< :: V_v -> V_v -> Bool
$c< :: V_v -> V_v -> Bool
compare :: V_v -> V_v -> Ordering
$ccompare :: V_v -> V_v -> Ordering
Ord, Int -> V_v -> ShowS
[V_v] -> ShowS
V_v -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [V_v] -> ShowS
$cshowList :: [V_v] -> ShowS
show :: V_v -> String
$cshow :: V_v -> String
showsPrec :: Int -> V_v -> ShowS
$cshowsPrec :: Int -> V_v -> ShowS
Show, forall x. Rep V_v x -> V_v
forall x. V_v -> Rep V_v x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep V_v x -> V_v
$cfrom :: forall x. V_v -> Rep V_v x
Generic)

class Cv x where
  _v' ::
    Prism' x ()
  _v ::
    x
  _v =
    forall x. Cv x => Prism' x ()
_v' forall t b. AReview t b -> b -> t
# ()

instance Cv () where
  _v' :: Prism' () ()
_v' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cv V_v where
  _v' :: Prism' V_v ()
_v' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> V_v
V_v)
      (\V_v
V_v -> forall a. a -> Maybe a
Just ())

instance Cv Char where
  _v' :: Prism' Char ()
_v' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'v')
      (\Char
c ->  case Char
c of
                Char
'v' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_v ::
  (Cv x, CharParsing p) =>
  p x
parse_v :: forall x (p :: * -> *). (Cv x, CharParsing p) => p x
parse_v =
  forall x. Cv x => x
_v forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'v' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"v"

data W_w =
  W_w
  deriving (W_w -> W_w -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: W_w -> W_w -> Bool
$c/= :: W_w -> W_w -> Bool
== :: W_w -> W_w -> Bool
$c== :: W_w -> W_w -> Bool
Eq, Eq W_w
W_w -> W_w -> Bool
W_w -> W_w -> Ordering
W_w -> W_w -> W_w
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: W_w -> W_w -> W_w
$cmin :: W_w -> W_w -> W_w
max :: W_w -> W_w -> W_w
$cmax :: W_w -> W_w -> W_w
>= :: W_w -> W_w -> Bool
$c>= :: W_w -> W_w -> Bool
> :: W_w -> W_w -> Bool
$c> :: W_w -> W_w -> Bool
<= :: W_w -> W_w -> Bool
$c<= :: W_w -> W_w -> Bool
< :: W_w -> W_w -> Bool
$c< :: W_w -> W_w -> Bool
compare :: W_w -> W_w -> Ordering
$ccompare :: W_w -> W_w -> Ordering
Ord, Int -> W_w -> ShowS
[W_w] -> ShowS
W_w -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [W_w] -> ShowS
$cshowList :: [W_w] -> ShowS
show :: W_w -> String
$cshow :: W_w -> String
showsPrec :: Int -> W_w -> ShowS
$cshowsPrec :: Int -> W_w -> ShowS
Show, forall x. Rep W_w x -> W_w
forall x. W_w -> Rep W_w x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep W_w x -> W_w
$cfrom :: forall x. W_w -> Rep W_w x
Generic)

class Cw x where
  _w' ::
    Prism' x ()
  _w ::
    x
  _w =
    forall x. Cw x => Prism' x ()
_w' forall t b. AReview t b -> b -> t
# ()

instance Cw () where
  _w' :: Prism' () ()
_w' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cw W_w where
  _w' :: Prism' W_w ()
_w' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> W_w
W_w)
      (\W_w
W_w -> forall a. a -> Maybe a
Just ())

instance Cw Char where
  _w' :: Prism' Char ()
_w' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'w')
      (\Char
c ->  case Char
c of
                Char
'w' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_w ::
  (Cw x, CharParsing p) =>
  p x
parse_w :: forall x (p :: * -> *). (Cw x, CharParsing p) => p x
parse_w =
  forall x. Cw x => x
_w forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'w' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"w"

data X_x =
  X_x
  deriving (X_x -> X_x -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: X_x -> X_x -> Bool
$c/= :: X_x -> X_x -> Bool
== :: X_x -> X_x -> Bool
$c== :: X_x -> X_x -> Bool
Eq, Eq X_x
X_x -> X_x -> Bool
X_x -> X_x -> Ordering
X_x -> X_x -> X_x
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: X_x -> X_x -> X_x
$cmin :: X_x -> X_x -> X_x
max :: X_x -> X_x -> X_x
$cmax :: X_x -> X_x -> X_x
>= :: X_x -> X_x -> Bool
$c>= :: X_x -> X_x -> Bool
> :: X_x -> X_x -> Bool
$c> :: X_x -> X_x -> Bool
<= :: X_x -> X_x -> Bool
$c<= :: X_x -> X_x -> Bool
< :: X_x -> X_x -> Bool
$c< :: X_x -> X_x -> Bool
compare :: X_x -> X_x -> Ordering
$ccompare :: X_x -> X_x -> Ordering
Ord, Int -> X_x -> ShowS
[X_x] -> ShowS
X_x -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [X_x] -> ShowS
$cshowList :: [X_x] -> ShowS
show :: X_x -> String
$cshow :: X_x -> String
showsPrec :: Int -> X_x -> ShowS
$cshowsPrec :: Int -> X_x -> ShowS
Show, forall x. Rep X_x x -> X_x
forall x. X_x -> Rep X_x x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep X_x x -> X_x
$cfrom :: forall x. X_x -> Rep X_x x
Generic)

class Cx x where
  _x' ::
    Prism' x ()
  _x ::
    x
  _x =
    forall x. Cx x => Prism' x ()
_x' forall t b. AReview t b -> b -> t
# ()

instance Cx () where
  _x' :: Prism' () ()
_x' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cx X_x where
  _x' :: Prism' X_x ()
_x' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> X_x
X_x)
      (\X_x
X_x -> forall a. a -> Maybe a
Just ())

instance Cx Char where
  _x' :: Prism' Char ()
_x' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'x')
      (\Char
c ->  case Char
c of
                Char
'x' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_x ::
  (Cx x, CharParsing p) =>
  p x
parse_x :: forall x (p :: * -> *). (Cx x, CharParsing p) => p x
parse_x =
  forall x. Cx x => x
_x forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'x' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"x"

data Y_y =
  Y_y
  deriving (Y_y -> Y_y -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Y_y -> Y_y -> Bool
$c/= :: Y_y -> Y_y -> Bool
== :: Y_y -> Y_y -> Bool
$c== :: Y_y -> Y_y -> Bool
Eq, Eq Y_y
Y_y -> Y_y -> Bool
Y_y -> Y_y -> Ordering
Y_y -> Y_y -> Y_y
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Y_y -> Y_y -> Y_y
$cmin :: Y_y -> Y_y -> Y_y
max :: Y_y -> Y_y -> Y_y
$cmax :: Y_y -> Y_y -> Y_y
>= :: Y_y -> Y_y -> Bool
$c>= :: Y_y -> Y_y -> Bool
> :: Y_y -> Y_y -> Bool
$c> :: Y_y -> Y_y -> Bool
<= :: Y_y -> Y_y -> Bool
$c<= :: Y_y -> Y_y -> Bool
< :: Y_y -> Y_y -> Bool
$c< :: Y_y -> Y_y -> Bool
compare :: Y_y -> Y_y -> Ordering
$ccompare :: Y_y -> Y_y -> Ordering
Ord, Int -> Y_y -> ShowS
[Y_y] -> ShowS
Y_y -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Y_y] -> ShowS
$cshowList :: [Y_y] -> ShowS
show :: Y_y -> String
$cshow :: Y_y -> String
showsPrec :: Int -> Y_y -> ShowS
$cshowsPrec :: Int -> Y_y -> ShowS
Show, forall x. Rep Y_y x -> Y_y
forall x. Y_y -> Rep Y_y x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Y_y x -> Y_y
$cfrom :: forall x. Y_y -> Rep Y_y x
Generic)

class Cy x where
  _y' ::
    Prism' x ()
  _y ::
    x
  _y =
    forall x. Cy x => Prism' x ()
_y' forall t b. AReview t b -> b -> t
# ()

instance Cy () where
  _y' :: Prism' () ()
_y' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cy Y_y where
  _y' :: Prism' Y_y ()
_y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Y_y
Y_y)
      (\Y_y
Y_y -> forall a. a -> Maybe a
Just ())

instance Cy Char where
  _y' :: Prism' Char ()
_y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'y')
      (\Char
c ->  case Char
c of
                Char
'y' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_y ::
  (Cy x, CharParsing p) =>
  p x
parse_y :: forall x (p :: * -> *). (Cy x, CharParsing p) => p x
parse_y =
  forall x. Cy x => x
_y forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'y' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"y"

data Z_z =
  Z_z
  deriving (Z_z -> Z_z -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Z_z -> Z_z -> Bool
$c/= :: Z_z -> Z_z -> Bool
== :: Z_z -> Z_z -> Bool
$c== :: Z_z -> Z_z -> Bool
Eq, Eq Z_z
Z_z -> Z_z -> Bool
Z_z -> Z_z -> Ordering
Z_z -> Z_z -> Z_z
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Z_z -> Z_z -> Z_z
$cmin :: Z_z -> Z_z -> Z_z
max :: Z_z -> Z_z -> Z_z
$cmax :: Z_z -> Z_z -> Z_z
>= :: Z_z -> Z_z -> Bool
$c>= :: Z_z -> Z_z -> Bool
> :: Z_z -> Z_z -> Bool
$c> :: Z_z -> Z_z -> Bool
<= :: Z_z -> Z_z -> Bool
$c<= :: Z_z -> Z_z -> Bool
< :: Z_z -> Z_z -> Bool
$c< :: Z_z -> Z_z -> Bool
compare :: Z_z -> Z_z -> Ordering
$ccompare :: Z_z -> Z_z -> Ordering
Ord, Int -> Z_z -> ShowS
[Z_z] -> ShowS
Z_z -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Z_z] -> ShowS
$cshowList :: [Z_z] -> ShowS
show :: Z_z -> String
$cshow :: Z_z -> String
showsPrec :: Int -> Z_z -> ShowS
$cshowsPrec :: Int -> Z_z -> ShowS
Show, forall x. Rep Z_z x -> Z_z
forall x. Z_z -> Rep Z_z x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Z_z x -> Z_z
$cfrom :: forall x. Z_z -> Rep Z_z x
Generic)

class Cz x where
  _z' ::
    Prism' x ()
  _z ::
    x
  _z =
    forall x. Cz x => Prism' x ()
_z' forall t b. AReview t b -> b -> t
# ()

instance Cz () where
  _z' :: Prism' () ()
_z' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance Cz Z_z where
  _z' :: Prism' Z_z ()
_z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Z_z
Z_z)
      (\Z_z
Z_z -> forall a. a -> Maybe a
Just ())

instance Cz Char where
  _z' :: Prism' Char ()
_z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'z')
      (\Char
c ->  case Char
c of
                Char
'z' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_z ::
  (Cz x, CharParsing p) =>
  p x
parse_z :: forall x (p :: * -> *). (Cz x, CharParsing p) => p x
parse_z =
  forall x. Cz x => x
_z forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'z' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"z"

data A_A =
  A_A
  deriving (A_A -> A_A -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: A_A -> A_A -> Bool
$c/= :: A_A -> A_A -> Bool
== :: A_A -> A_A -> Bool
$c== :: A_A -> A_A -> Bool
Eq, Eq A_A
A_A -> A_A -> Bool
A_A -> A_A -> Ordering
A_A -> A_A -> A_A
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: A_A -> A_A -> A_A
$cmin :: A_A -> A_A -> A_A
max :: A_A -> A_A -> A_A
$cmax :: A_A -> A_A -> A_A
>= :: A_A -> A_A -> Bool
$c>= :: A_A -> A_A -> Bool
> :: A_A -> A_A -> Bool
$c> :: A_A -> A_A -> Bool
<= :: A_A -> A_A -> Bool
$c<= :: A_A -> A_A -> Bool
< :: A_A -> A_A -> Bool
$c< :: A_A -> A_A -> Bool
compare :: A_A -> A_A -> Ordering
$ccompare :: A_A -> A_A -> Ordering
Ord, Int -> A_A -> ShowS
[A_A] -> ShowS
A_A -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [A_A] -> ShowS
$cshowList :: [A_A] -> ShowS
show :: A_A -> String
$cshow :: A_A -> String
showsPrec :: Int -> A_A -> ShowS
$cshowsPrec :: Int -> A_A -> ShowS
Show, forall x. Rep A_A x -> A_A
forall x. A_A -> Rep A_A x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep A_A x -> A_A
$cfrom :: forall x. A_A -> Rep A_A x
Generic)

class CA x where
  _A' ::
    Prism' x ()
  _A ::
    x
  _A =
    forall x. CA x => Prism' x ()
_A' forall t b. AReview t b -> b -> t
# ()

instance CA () where
  _A' :: Prism' () ()
_A' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CA A_A where
  _A' :: Prism' A_A ()
_A' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> A_A
A_A)
      (\A_A
A_A -> forall a. a -> Maybe a
Just ())

instance CA Char where
  _A' :: Prism' Char ()
_A' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'A')
      (\Char
c ->  case Char
c of
                Char
'A' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_A ::
  (CA x, CharParsing p) =>
  p x
parse_A :: forall x (p :: * -> *). (CA x, CharParsing p) => p x
parse_A =
  forall x. CA x => x
_A forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'A' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"A"

data B_B =
  B_B
  deriving (B_B -> B_B -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: B_B -> B_B -> Bool
$c/= :: B_B -> B_B -> Bool
== :: B_B -> B_B -> Bool
$c== :: B_B -> B_B -> Bool
Eq, Eq B_B
B_B -> B_B -> Bool
B_B -> B_B -> Ordering
B_B -> B_B -> B_B
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: B_B -> B_B -> B_B
$cmin :: B_B -> B_B -> B_B
max :: B_B -> B_B -> B_B
$cmax :: B_B -> B_B -> B_B
>= :: B_B -> B_B -> Bool
$c>= :: B_B -> B_B -> Bool
> :: B_B -> B_B -> Bool
$c> :: B_B -> B_B -> Bool
<= :: B_B -> B_B -> Bool
$c<= :: B_B -> B_B -> Bool
< :: B_B -> B_B -> Bool
$c< :: B_B -> B_B -> Bool
compare :: B_B -> B_B -> Ordering
$ccompare :: B_B -> B_B -> Ordering
Ord, Int -> B_B -> ShowS
[B_B] -> ShowS
B_B -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [B_B] -> ShowS
$cshowList :: [B_B] -> ShowS
show :: B_B -> String
$cshow :: B_B -> String
showsPrec :: Int -> B_B -> ShowS
$cshowsPrec :: Int -> B_B -> ShowS
Show, forall x. Rep B_B x -> B_B
forall x. B_B -> Rep B_B x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep B_B x -> B_B
$cfrom :: forall x. B_B -> Rep B_B x
Generic)

class CB x where
  _B' ::
    Prism' x ()
  _B ::
    x
  _B =
    forall x. CB x => Prism' x ()
_B' forall t b. AReview t b -> b -> t
# ()

instance CB () where
  _B' :: Prism' () ()
_B' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CB B_B where
  _B' :: Prism' B_B ()
_B' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> B_B
B_B)
      (\B_B
B_B -> forall a. a -> Maybe a
Just ())

instance CB Char where
  _B' :: Prism' Char ()
_B' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'B')
      (\Char
c ->  case Char
c of
                Char
'B' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_B ::
  (CB x, CharParsing p) =>
  p x
parse_B :: forall x (p :: * -> *). (CB x, CharParsing p) => p x
parse_B =
  forall x. CB x => x
_B forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'B' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"B"

data C_C =
  C_C
  deriving (C_C -> C_C -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: C_C -> C_C -> Bool
$c/= :: C_C -> C_C -> Bool
== :: C_C -> C_C -> Bool
$c== :: C_C -> C_C -> Bool
Eq, Eq C_C
C_C -> C_C -> Bool
C_C -> C_C -> Ordering
C_C -> C_C -> C_C
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: C_C -> C_C -> C_C
$cmin :: C_C -> C_C -> C_C
max :: C_C -> C_C -> C_C
$cmax :: C_C -> C_C -> C_C
>= :: C_C -> C_C -> Bool
$c>= :: C_C -> C_C -> Bool
> :: C_C -> C_C -> Bool
$c> :: C_C -> C_C -> Bool
<= :: C_C -> C_C -> Bool
$c<= :: C_C -> C_C -> Bool
< :: C_C -> C_C -> Bool
$c< :: C_C -> C_C -> Bool
compare :: C_C -> C_C -> Ordering
$ccompare :: C_C -> C_C -> Ordering
Ord, Int -> C_C -> ShowS
[C_C] -> ShowS
C_C -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [C_C] -> ShowS
$cshowList :: [C_C] -> ShowS
show :: C_C -> String
$cshow :: C_C -> String
showsPrec :: Int -> C_C -> ShowS
$cshowsPrec :: Int -> C_C -> ShowS
Show, forall x. Rep C_C x -> C_C
forall x. C_C -> Rep C_C x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep C_C x -> C_C
$cfrom :: forall x. C_C -> Rep C_C x
Generic)

class CC x where
  _C' ::
    Prism' x ()
  _C ::
    x
  _C =
    forall x. CC x => Prism' x ()
_C' forall t b. AReview t b -> b -> t
# ()

instance CC () where
  _C' :: Prism' () ()
_C' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CC C_C where
  _C' :: Prism' C_C ()
_C' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> C_C
C_C)
      (\C_C
C_C -> forall a. a -> Maybe a
Just ())

instance CC Char where
  _C' :: Prism' Char ()
_C' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'C')
      (\Char
c ->  case Char
c of
                Char
'C' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_C ::
  (CC x, CharParsing p) =>
  p x
parse_C :: forall x (p :: * -> *). (CC x, CharParsing p) => p x
parse_C =
  forall x. CC x => x
_C forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'C' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"C"

data D_D =
  D_D
  deriving (D_D -> D_D -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: D_D -> D_D -> Bool
$c/= :: D_D -> D_D -> Bool
== :: D_D -> D_D -> Bool
$c== :: D_D -> D_D -> Bool
Eq, Eq D_D
D_D -> D_D -> Bool
D_D -> D_D -> Ordering
D_D -> D_D -> D_D
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: D_D -> D_D -> D_D
$cmin :: D_D -> D_D -> D_D
max :: D_D -> D_D -> D_D
$cmax :: D_D -> D_D -> D_D
>= :: D_D -> D_D -> Bool
$c>= :: D_D -> D_D -> Bool
> :: D_D -> D_D -> Bool
$c> :: D_D -> D_D -> Bool
<= :: D_D -> D_D -> Bool
$c<= :: D_D -> D_D -> Bool
< :: D_D -> D_D -> Bool
$c< :: D_D -> D_D -> Bool
compare :: D_D -> D_D -> Ordering
$ccompare :: D_D -> D_D -> Ordering
Ord, Int -> D_D -> ShowS
[D_D] -> ShowS
D_D -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [D_D] -> ShowS
$cshowList :: [D_D] -> ShowS
show :: D_D -> String
$cshow :: D_D -> String
showsPrec :: Int -> D_D -> ShowS
$cshowsPrec :: Int -> D_D -> ShowS
Show, forall x. Rep D_D x -> D_D
forall x. D_D -> Rep D_D x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep D_D x -> D_D
$cfrom :: forall x. D_D -> Rep D_D x
Generic)

class CD x where
  _D' ::
    Prism' x ()
  _D ::
    x
  _D =
    forall x. CD x => Prism' x ()
_D' forall t b. AReview t b -> b -> t
# ()

instance CD () where
  _D' :: Prism' () ()
_D' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CD D_D where
  _D' :: Prism' D_D ()
_D' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> D_D
D_D)
      (\D_D
D_D -> forall a. a -> Maybe a
Just ())

instance CD Char where
  _D' :: Prism' Char ()
_D' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'D')
      (\Char
c ->  case Char
c of
                Char
'D' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_D ::
  (CD x, CharParsing p) =>
  p x
parse_D :: forall x (p :: * -> *). (CD x, CharParsing p) => p x
parse_D =
  forall x. CD x => x
_D forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'D' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"D"

data E_E =
  E_E
  deriving (E_E -> E_E -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: E_E -> E_E -> Bool
$c/= :: E_E -> E_E -> Bool
== :: E_E -> E_E -> Bool
$c== :: E_E -> E_E -> Bool
Eq, Eq E_E
E_E -> E_E -> Bool
E_E -> E_E -> Ordering
E_E -> E_E -> E_E
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: E_E -> E_E -> E_E
$cmin :: E_E -> E_E -> E_E
max :: E_E -> E_E -> E_E
$cmax :: E_E -> E_E -> E_E
>= :: E_E -> E_E -> Bool
$c>= :: E_E -> E_E -> Bool
> :: E_E -> E_E -> Bool
$c> :: E_E -> E_E -> Bool
<= :: E_E -> E_E -> Bool
$c<= :: E_E -> E_E -> Bool
< :: E_E -> E_E -> Bool
$c< :: E_E -> E_E -> Bool
compare :: E_E -> E_E -> Ordering
$ccompare :: E_E -> E_E -> Ordering
Ord, Int -> E_E -> ShowS
[E_E] -> ShowS
E_E -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [E_E] -> ShowS
$cshowList :: [E_E] -> ShowS
show :: E_E -> String
$cshow :: E_E -> String
showsPrec :: Int -> E_E -> ShowS
$cshowsPrec :: Int -> E_E -> ShowS
Show, forall x. Rep E_E x -> E_E
forall x. E_E -> Rep E_E x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep E_E x -> E_E
$cfrom :: forall x. E_E -> Rep E_E x
Generic)

class CE x where
  _E' ::
    Prism' x ()
  _E ::
    x
  _E =
    forall x. CE x => Prism' x ()
_E' forall t b. AReview t b -> b -> t
# ()

instance CE () where
  _E' :: Prism' () ()
_E' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CE E_E where
  _E' :: Prism' E_E ()
_E' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> E_E
E_E)
      (\E_E
E_E -> forall a. a -> Maybe a
Just ())

instance CE Char where
  _E' :: Prism' Char ()
_E' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'E')
      (\Char
c ->  case Char
c of
                Char
'E' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_E ::
  (CE x, CharParsing p) =>
  p x
parse_E :: forall x (p :: * -> *). (CE x, CharParsing p) => p x
parse_E =
  forall x. CE x => x
_E forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'E' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"E"

data F_F =
  F_F
  deriving (F_F -> F_F -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: F_F -> F_F -> Bool
$c/= :: F_F -> F_F -> Bool
== :: F_F -> F_F -> Bool
$c== :: F_F -> F_F -> Bool
Eq, Eq F_F
F_F -> F_F -> Bool
F_F -> F_F -> Ordering
F_F -> F_F -> F_F
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: F_F -> F_F -> F_F
$cmin :: F_F -> F_F -> F_F
max :: F_F -> F_F -> F_F
$cmax :: F_F -> F_F -> F_F
>= :: F_F -> F_F -> Bool
$c>= :: F_F -> F_F -> Bool
> :: F_F -> F_F -> Bool
$c> :: F_F -> F_F -> Bool
<= :: F_F -> F_F -> Bool
$c<= :: F_F -> F_F -> Bool
< :: F_F -> F_F -> Bool
$c< :: F_F -> F_F -> Bool
compare :: F_F -> F_F -> Ordering
$ccompare :: F_F -> F_F -> Ordering
Ord, Int -> F_F -> ShowS
[F_F] -> ShowS
F_F -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [F_F] -> ShowS
$cshowList :: [F_F] -> ShowS
show :: F_F -> String
$cshow :: F_F -> String
showsPrec :: Int -> F_F -> ShowS
$cshowsPrec :: Int -> F_F -> ShowS
Show, forall x. Rep F_F x -> F_F
forall x. F_F -> Rep F_F x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep F_F x -> F_F
$cfrom :: forall x. F_F -> Rep F_F x
Generic)

class CF x where
  _F' ::
    Prism' x ()
  _F ::
    x
  _F =
    forall x. CF x => Prism' x ()
_F' forall t b. AReview t b -> b -> t
# ()

instance CF () where
  _F' :: Prism' () ()
_F' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CF F_F where
  _F' :: Prism' F_F ()
_F' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> F_F
F_F)
      (\F_F
F_F -> forall a. a -> Maybe a
Just ())

instance CF Char where
  _F' :: Prism' Char ()
_F' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'F')
      (\Char
c ->  case Char
c of
                Char
'F' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_F ::
  (CF x, CharParsing p) =>
  p x
parse_F :: forall x (p :: * -> *). (CF x, CharParsing p) => p x
parse_F =
  forall x. CF x => x
_F forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'F' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"F"

data G_G =
  G_G
  deriving (G_G -> G_G -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: G_G -> G_G -> Bool
$c/= :: G_G -> G_G -> Bool
== :: G_G -> G_G -> Bool
$c== :: G_G -> G_G -> Bool
Eq, Eq G_G
G_G -> G_G -> Bool
G_G -> G_G -> Ordering
G_G -> G_G -> G_G
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: G_G -> G_G -> G_G
$cmin :: G_G -> G_G -> G_G
max :: G_G -> G_G -> G_G
$cmax :: G_G -> G_G -> G_G
>= :: G_G -> G_G -> Bool
$c>= :: G_G -> G_G -> Bool
> :: G_G -> G_G -> Bool
$c> :: G_G -> G_G -> Bool
<= :: G_G -> G_G -> Bool
$c<= :: G_G -> G_G -> Bool
< :: G_G -> G_G -> Bool
$c< :: G_G -> G_G -> Bool
compare :: G_G -> G_G -> Ordering
$ccompare :: G_G -> G_G -> Ordering
Ord, Int -> G_G -> ShowS
[G_G] -> ShowS
G_G -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [G_G] -> ShowS
$cshowList :: [G_G] -> ShowS
show :: G_G -> String
$cshow :: G_G -> String
showsPrec :: Int -> G_G -> ShowS
$cshowsPrec :: Int -> G_G -> ShowS
Show, forall x. Rep G_G x -> G_G
forall x. G_G -> Rep G_G x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep G_G x -> G_G
$cfrom :: forall x. G_G -> Rep G_G x
Generic)

class CG x where
  _G' ::
    Prism' x ()
  _G ::
    x
  _G =
    forall x. CG x => Prism' x ()
_G' forall t b. AReview t b -> b -> t
# ()

instance CG () where
  _G' :: Prism' () ()
_G' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CG G_G where
  _G' :: Prism' G_G ()
_G' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> G_G
G_G)
      (\G_G
G_G -> forall a. a -> Maybe a
Just ())

instance CG Char where
  _G' :: Prism' Char ()
_G' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'G')
      (\Char
c ->  case Char
c of
                Char
'G' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_G ::
  (CG x, CharParsing p) =>
  p x
parse_G :: forall x (p :: * -> *). (CG x, CharParsing p) => p x
parse_G =
  forall x. CG x => x
_G forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'G' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"G"

data H_H =
  H_H
  deriving (H_H -> H_H -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: H_H -> H_H -> Bool
$c/= :: H_H -> H_H -> Bool
== :: H_H -> H_H -> Bool
$c== :: H_H -> H_H -> Bool
Eq, Eq H_H
H_H -> H_H -> Bool
H_H -> H_H -> Ordering
H_H -> H_H -> H_H
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: H_H -> H_H -> H_H
$cmin :: H_H -> H_H -> H_H
max :: H_H -> H_H -> H_H
$cmax :: H_H -> H_H -> H_H
>= :: H_H -> H_H -> Bool
$c>= :: H_H -> H_H -> Bool
> :: H_H -> H_H -> Bool
$c> :: H_H -> H_H -> Bool
<= :: H_H -> H_H -> Bool
$c<= :: H_H -> H_H -> Bool
< :: H_H -> H_H -> Bool
$c< :: H_H -> H_H -> Bool
compare :: H_H -> H_H -> Ordering
$ccompare :: H_H -> H_H -> Ordering
Ord, Int -> H_H -> ShowS
[H_H] -> ShowS
H_H -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [H_H] -> ShowS
$cshowList :: [H_H] -> ShowS
show :: H_H -> String
$cshow :: H_H -> String
showsPrec :: Int -> H_H -> ShowS
$cshowsPrec :: Int -> H_H -> ShowS
Show, forall x. Rep H_H x -> H_H
forall x. H_H -> Rep H_H x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep H_H x -> H_H
$cfrom :: forall x. H_H -> Rep H_H x
Generic)

class CH x where
  _H' ::
    Prism' x ()
  _H ::
    x
  _H =
    forall x. CH x => Prism' x ()
_H' forall t b. AReview t b -> b -> t
# ()

instance CH () where
  _H' :: Prism' () ()
_H' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CH H_H where
  _H' :: Prism' H_H ()
_H' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> H_H
H_H)
      (\H_H
H_H -> forall a. a -> Maybe a
Just ())

instance CH Char where
  _H' :: Prism' Char ()
_H' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'H')
      (\Char
c ->  case Char
c of
                Char
'H' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_H ::
  (CH x, CharParsing p) =>
  p x
parse_H :: forall x (p :: * -> *). (CH x, CharParsing p) => p x
parse_H =
  forall x. CH x => x
_H forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'H' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"H"

data I_I =
  I_I
  deriving (I_I -> I_I -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: I_I -> I_I -> Bool
$c/= :: I_I -> I_I -> Bool
== :: I_I -> I_I -> Bool
$c== :: I_I -> I_I -> Bool
Eq, Eq I_I
I_I -> I_I -> Bool
I_I -> I_I -> Ordering
I_I -> I_I -> I_I
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: I_I -> I_I -> I_I
$cmin :: I_I -> I_I -> I_I
max :: I_I -> I_I -> I_I
$cmax :: I_I -> I_I -> I_I
>= :: I_I -> I_I -> Bool
$c>= :: I_I -> I_I -> Bool
> :: I_I -> I_I -> Bool
$c> :: I_I -> I_I -> Bool
<= :: I_I -> I_I -> Bool
$c<= :: I_I -> I_I -> Bool
< :: I_I -> I_I -> Bool
$c< :: I_I -> I_I -> Bool
compare :: I_I -> I_I -> Ordering
$ccompare :: I_I -> I_I -> Ordering
Ord, Int -> I_I -> ShowS
[I_I] -> ShowS
I_I -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [I_I] -> ShowS
$cshowList :: [I_I] -> ShowS
show :: I_I -> String
$cshow :: I_I -> String
showsPrec :: Int -> I_I -> ShowS
$cshowsPrec :: Int -> I_I -> ShowS
Show, forall x. Rep I_I x -> I_I
forall x. I_I -> Rep I_I x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep I_I x -> I_I
$cfrom :: forall x. I_I -> Rep I_I x
Generic)

class CI x where
  _I' ::
    Prism' x ()
  _I ::
    x
  _I =
    forall x. CI x => Prism' x ()
_I' forall t b. AReview t b -> b -> t
# ()

instance CI () where
  _I' :: Prism' () ()
_I' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CI I_I where
  _I' :: Prism' I_I ()
_I' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> I_I
I_I)
      (\I_I
I_I -> forall a. a -> Maybe a
Just ())

instance CI Char where
  _I' :: Prism' Char ()
_I' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'I')
      (\Char
c ->  case Char
c of
                Char
'I' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_I ::
  (CI x, CharParsing p) =>
  p x
parse_I :: forall x (p :: * -> *). (CI x, CharParsing p) => p x
parse_I =
  forall x. CI x => x
_I forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'I' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"I"

data J_J =
  J_J
  deriving (J_J -> J_J -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: J_J -> J_J -> Bool
$c/= :: J_J -> J_J -> Bool
== :: J_J -> J_J -> Bool
$c== :: J_J -> J_J -> Bool
Eq, Eq J_J
J_J -> J_J -> Bool
J_J -> J_J -> Ordering
J_J -> J_J -> J_J
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: J_J -> J_J -> J_J
$cmin :: J_J -> J_J -> J_J
max :: J_J -> J_J -> J_J
$cmax :: J_J -> J_J -> J_J
>= :: J_J -> J_J -> Bool
$c>= :: J_J -> J_J -> Bool
> :: J_J -> J_J -> Bool
$c> :: J_J -> J_J -> Bool
<= :: J_J -> J_J -> Bool
$c<= :: J_J -> J_J -> Bool
< :: J_J -> J_J -> Bool
$c< :: J_J -> J_J -> Bool
compare :: J_J -> J_J -> Ordering
$ccompare :: J_J -> J_J -> Ordering
Ord, Int -> J_J -> ShowS
[J_J] -> ShowS
J_J -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [J_J] -> ShowS
$cshowList :: [J_J] -> ShowS
show :: J_J -> String
$cshow :: J_J -> String
showsPrec :: Int -> J_J -> ShowS
$cshowsPrec :: Int -> J_J -> ShowS
Show, forall x. Rep J_J x -> J_J
forall x. J_J -> Rep J_J x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep J_J x -> J_J
$cfrom :: forall x. J_J -> Rep J_J x
Generic)

class CJ x where
  _J' ::
    Prism' x ()
  _J ::
    x
  _J =
    forall x. CJ x => Prism' x ()
_J' forall t b. AReview t b -> b -> t
# ()

instance CJ () where
  _J' :: Prism' () ()
_J' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CJ J_J where
  _J' :: Prism' J_J ()
_J' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> J_J
J_J)
      (\J_J
J_J -> forall a. a -> Maybe a
Just ())

instance CJ Char where
  _J' :: Prism' Char ()
_J' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'J')
      (\Char
c ->  case Char
c of
                Char
'J' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_J ::
  (CJ x, CharParsing p) =>
  p x
parse_J :: forall x (p :: * -> *). (CJ x, CharParsing p) => p x
parse_J =
  forall x. CJ x => x
_J forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'J' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"J"

data K_K =
  K_K
  deriving (K_K -> K_K -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: K_K -> K_K -> Bool
$c/= :: K_K -> K_K -> Bool
== :: K_K -> K_K -> Bool
$c== :: K_K -> K_K -> Bool
Eq, Eq K_K
K_K -> K_K -> Bool
K_K -> K_K -> Ordering
K_K -> K_K -> K_K
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: K_K -> K_K -> K_K
$cmin :: K_K -> K_K -> K_K
max :: K_K -> K_K -> K_K
$cmax :: K_K -> K_K -> K_K
>= :: K_K -> K_K -> Bool
$c>= :: K_K -> K_K -> Bool
> :: K_K -> K_K -> Bool
$c> :: K_K -> K_K -> Bool
<= :: K_K -> K_K -> Bool
$c<= :: K_K -> K_K -> Bool
< :: K_K -> K_K -> Bool
$c< :: K_K -> K_K -> Bool
compare :: K_K -> K_K -> Ordering
$ccompare :: K_K -> K_K -> Ordering
Ord, Int -> K_K -> ShowS
[K_K] -> ShowS
K_K -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [K_K] -> ShowS
$cshowList :: [K_K] -> ShowS
show :: K_K -> String
$cshow :: K_K -> String
showsPrec :: Int -> K_K -> ShowS
$cshowsPrec :: Int -> K_K -> ShowS
Show, forall x. Rep K_K x -> K_K
forall x. K_K -> Rep K_K x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep K_K x -> K_K
$cfrom :: forall x. K_K -> Rep K_K x
Generic)

class CK x where
  _K' ::
    Prism' x ()
  _K ::
    x
  _K =
    forall x. CK x => Prism' x ()
_K' forall t b. AReview t b -> b -> t
# ()

instance CK () where
  _K' :: Prism' () ()
_K' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CK K_K where
  _K' :: Prism' K_K ()
_K' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> K_K
K_K)
      (\K_K
K_K -> forall a. a -> Maybe a
Just ())

instance CK Char where
  _K' :: Prism' Char ()
_K' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'K')
      (\Char
c ->  case Char
c of
                Char
'K' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_K ::
  (CK x, CharParsing p) =>
  p x
parse_K :: forall x (p :: * -> *). (CK x, CharParsing p) => p x
parse_K =
  forall x. CK x => x
_K forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'K' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"K"

data L_L =
  L_L
  deriving (L_L -> L_L -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: L_L -> L_L -> Bool
$c/= :: L_L -> L_L -> Bool
== :: L_L -> L_L -> Bool
$c== :: L_L -> L_L -> Bool
Eq, Eq L_L
L_L -> L_L -> Bool
L_L -> L_L -> Ordering
L_L -> L_L -> L_L
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: L_L -> L_L -> L_L
$cmin :: L_L -> L_L -> L_L
max :: L_L -> L_L -> L_L
$cmax :: L_L -> L_L -> L_L
>= :: L_L -> L_L -> Bool
$c>= :: L_L -> L_L -> Bool
> :: L_L -> L_L -> Bool
$c> :: L_L -> L_L -> Bool
<= :: L_L -> L_L -> Bool
$c<= :: L_L -> L_L -> Bool
< :: L_L -> L_L -> Bool
$c< :: L_L -> L_L -> Bool
compare :: L_L -> L_L -> Ordering
$ccompare :: L_L -> L_L -> Ordering
Ord, Int -> L_L -> ShowS
[L_L] -> ShowS
L_L -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [L_L] -> ShowS
$cshowList :: [L_L] -> ShowS
show :: L_L -> String
$cshow :: L_L -> String
showsPrec :: Int -> L_L -> ShowS
$cshowsPrec :: Int -> L_L -> ShowS
Show, forall x. Rep L_L x -> L_L
forall x. L_L -> Rep L_L x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep L_L x -> L_L
$cfrom :: forall x. L_L -> Rep L_L x
Generic)

class CL x where
  _L' ::
    Prism' x ()
  _L ::
    x
  _L =
    forall x. CL x => Prism' x ()
_L' forall t b. AReview t b -> b -> t
# ()

instance CL () where
  _L' :: Prism' () ()
_L' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CL L_L where
  _L' :: Prism' L_L ()
_L' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> L_L
L_L)
      (\L_L
L_L -> forall a. a -> Maybe a
Just ())

instance CL Char where
  _L' :: Prism' Char ()
_L' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'L')
      (\Char
c ->  case Char
c of
                Char
'L' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_L ::
  (CL x, CharParsing p) =>
  p x
parse_L :: forall x (p :: * -> *). (CL x, CharParsing p) => p x
parse_L =
  forall x. CL x => x
_L forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'L' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"L"

data M_M =
  M_M
  deriving (M_M -> M_M -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: M_M -> M_M -> Bool
$c/= :: M_M -> M_M -> Bool
== :: M_M -> M_M -> Bool
$c== :: M_M -> M_M -> Bool
Eq, Eq M_M
M_M -> M_M -> Bool
M_M -> M_M -> Ordering
M_M -> M_M -> M_M
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: M_M -> M_M -> M_M
$cmin :: M_M -> M_M -> M_M
max :: M_M -> M_M -> M_M
$cmax :: M_M -> M_M -> M_M
>= :: M_M -> M_M -> Bool
$c>= :: M_M -> M_M -> Bool
> :: M_M -> M_M -> Bool
$c> :: M_M -> M_M -> Bool
<= :: M_M -> M_M -> Bool
$c<= :: M_M -> M_M -> Bool
< :: M_M -> M_M -> Bool
$c< :: M_M -> M_M -> Bool
compare :: M_M -> M_M -> Ordering
$ccompare :: M_M -> M_M -> Ordering
Ord, Int -> M_M -> ShowS
[M_M] -> ShowS
M_M -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [M_M] -> ShowS
$cshowList :: [M_M] -> ShowS
show :: M_M -> String
$cshow :: M_M -> String
showsPrec :: Int -> M_M -> ShowS
$cshowsPrec :: Int -> M_M -> ShowS
Show, forall x. Rep M_M x -> M_M
forall x. M_M -> Rep M_M x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep M_M x -> M_M
$cfrom :: forall x. M_M -> Rep M_M x
Generic)

class CM x where
  _M' ::
    Prism' x ()
  _M ::
    x
  _M =
    forall x. CM x => Prism' x ()
_M' forall t b. AReview t b -> b -> t
# ()

instance CM () where
  _M' :: Prism' () ()
_M' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CM M_M where
  _M' :: Prism' M_M ()
_M' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> M_M
M_M)
      (\M_M
M_M -> forall a. a -> Maybe a
Just ())

instance CM Char where
  _M' :: Prism' Char ()
_M' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'M')
      (\Char
c ->  case Char
c of
                Char
'M' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_M ::
  (CM x, CharParsing p) =>
  p x
parse_M :: forall x (p :: * -> *). (CM x, CharParsing p) => p x
parse_M =
  forall x. CM x => x
_M forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'M' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"M"

data N_N =
  N_N
  deriving (N_N -> N_N -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: N_N -> N_N -> Bool
$c/= :: N_N -> N_N -> Bool
== :: N_N -> N_N -> Bool
$c== :: N_N -> N_N -> Bool
Eq, Eq N_N
N_N -> N_N -> Bool
N_N -> N_N -> Ordering
N_N -> N_N -> N_N
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: N_N -> N_N -> N_N
$cmin :: N_N -> N_N -> N_N
max :: N_N -> N_N -> N_N
$cmax :: N_N -> N_N -> N_N
>= :: N_N -> N_N -> Bool
$c>= :: N_N -> N_N -> Bool
> :: N_N -> N_N -> Bool
$c> :: N_N -> N_N -> Bool
<= :: N_N -> N_N -> Bool
$c<= :: N_N -> N_N -> Bool
< :: N_N -> N_N -> Bool
$c< :: N_N -> N_N -> Bool
compare :: N_N -> N_N -> Ordering
$ccompare :: N_N -> N_N -> Ordering
Ord, Int -> N_N -> ShowS
[N_N] -> ShowS
N_N -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [N_N] -> ShowS
$cshowList :: [N_N] -> ShowS
show :: N_N -> String
$cshow :: N_N -> String
showsPrec :: Int -> N_N -> ShowS
$cshowsPrec :: Int -> N_N -> ShowS
Show, forall x. Rep N_N x -> N_N
forall x. N_N -> Rep N_N x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep N_N x -> N_N
$cfrom :: forall x. N_N -> Rep N_N x
Generic)

class CN x where
  _N' ::
    Prism' x ()
  _N ::
    x
  _N =
    forall x. CN x => Prism' x ()
_N' forall t b. AReview t b -> b -> t
# ()

instance CN () where
  _N' :: Prism' () ()
_N' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CN N_N where
  _N' :: Prism' N_N ()
_N' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> N_N
N_N)
      (\N_N
N_N -> forall a. a -> Maybe a
Just ())

instance CN Char where
  _N' :: Prism' Char ()
_N' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'N')
      (\Char
c ->  case Char
c of
                Char
'N' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_N ::
  (CN x, CharParsing p) =>
  p x
parse_N :: forall x (p :: * -> *). (CN x, CharParsing p) => p x
parse_N =
  forall x. CN x => x
_N forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'N' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"N"

data O_O =
  O_O
  deriving (O_O -> O_O -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: O_O -> O_O -> Bool
$c/= :: O_O -> O_O -> Bool
== :: O_O -> O_O -> Bool
$c== :: O_O -> O_O -> Bool
Eq, Eq O_O
O_O -> O_O -> Bool
O_O -> O_O -> Ordering
O_O -> O_O -> O_O
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: O_O -> O_O -> O_O
$cmin :: O_O -> O_O -> O_O
max :: O_O -> O_O -> O_O
$cmax :: O_O -> O_O -> O_O
>= :: O_O -> O_O -> Bool
$c>= :: O_O -> O_O -> Bool
> :: O_O -> O_O -> Bool
$c> :: O_O -> O_O -> Bool
<= :: O_O -> O_O -> Bool
$c<= :: O_O -> O_O -> Bool
< :: O_O -> O_O -> Bool
$c< :: O_O -> O_O -> Bool
compare :: O_O -> O_O -> Ordering
$ccompare :: O_O -> O_O -> Ordering
Ord, Int -> O_O -> ShowS
[O_O] -> ShowS
O_O -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [O_O] -> ShowS
$cshowList :: [O_O] -> ShowS
show :: O_O -> String
$cshow :: O_O -> String
showsPrec :: Int -> O_O -> ShowS
$cshowsPrec :: Int -> O_O -> ShowS
Show, forall x. Rep O_O x -> O_O
forall x. O_O -> Rep O_O x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep O_O x -> O_O
$cfrom :: forall x. O_O -> Rep O_O x
Generic)

class CO x where
  _O' ::
    Prism' x ()
  _O ::
    x
  _O =
    forall x. CO x => Prism' x ()
_O' forall t b. AReview t b -> b -> t
# ()

instance CO () where
  _O' :: Prism' () ()
_O' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CO O_O where
  _O' :: Prism' O_O ()
_O' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> O_O
O_O)
      (\O_O
O_O -> forall a. a -> Maybe a
Just ())

instance CO Char where
  _O' :: Prism' Char ()
_O' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'O')
      (\Char
c ->  case Char
c of
                Char
'O' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_O ::
  (CO x, CharParsing p) =>
  p x
parse_O :: forall x (p :: * -> *). (CO x, CharParsing p) => p x
parse_O =
  forall x. CO x => x
_O forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'O' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"O"

data P_P =
  P_P
  deriving (P_P -> P_P -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: P_P -> P_P -> Bool
$c/= :: P_P -> P_P -> Bool
== :: P_P -> P_P -> Bool
$c== :: P_P -> P_P -> Bool
Eq, Eq P_P
P_P -> P_P -> Bool
P_P -> P_P -> Ordering
P_P -> P_P -> P_P
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: P_P -> P_P -> P_P
$cmin :: P_P -> P_P -> P_P
max :: P_P -> P_P -> P_P
$cmax :: P_P -> P_P -> P_P
>= :: P_P -> P_P -> Bool
$c>= :: P_P -> P_P -> Bool
> :: P_P -> P_P -> Bool
$c> :: P_P -> P_P -> Bool
<= :: P_P -> P_P -> Bool
$c<= :: P_P -> P_P -> Bool
< :: P_P -> P_P -> Bool
$c< :: P_P -> P_P -> Bool
compare :: P_P -> P_P -> Ordering
$ccompare :: P_P -> P_P -> Ordering
Ord, Int -> P_P -> ShowS
[P_P] -> ShowS
P_P -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [P_P] -> ShowS
$cshowList :: [P_P] -> ShowS
show :: P_P -> String
$cshow :: P_P -> String
showsPrec :: Int -> P_P -> ShowS
$cshowsPrec :: Int -> P_P -> ShowS
Show, forall x. Rep P_P x -> P_P
forall x. P_P -> Rep P_P x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep P_P x -> P_P
$cfrom :: forall x. P_P -> Rep P_P x
Generic)

class CP x where
  _P' ::
    Prism' x ()
  _P ::
    x
  _P =
    forall x. CP x => Prism' x ()
_P' forall t b. AReview t b -> b -> t
# ()

instance CP () where
  _P' :: Prism' () ()
_P' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CP P_P where
  _P' :: Prism' P_P ()
_P' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> P_P
P_P)
      (\P_P
P_P -> forall a. a -> Maybe a
Just ())

instance CP Char where
  _P' :: Prism' Char ()
_P' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'P')
      (\Char
c ->  case Char
c of
                Char
'P' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_P ::
  (CP x, CharParsing p) =>
  p x
parse_P :: forall x (p :: * -> *). (CP x, CharParsing p) => p x
parse_P =
  forall x. CP x => x
_P forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'P' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"P"

data Q_Q =
  Q_Q
  deriving (Q_Q -> Q_Q -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Q_Q -> Q_Q -> Bool
$c/= :: Q_Q -> Q_Q -> Bool
== :: Q_Q -> Q_Q -> Bool
$c== :: Q_Q -> Q_Q -> Bool
Eq, Eq Q_Q
Q_Q -> Q_Q -> Bool
Q_Q -> Q_Q -> Ordering
Q_Q -> Q_Q -> Q_Q
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Q_Q -> Q_Q -> Q_Q
$cmin :: Q_Q -> Q_Q -> Q_Q
max :: Q_Q -> Q_Q -> Q_Q
$cmax :: Q_Q -> Q_Q -> Q_Q
>= :: Q_Q -> Q_Q -> Bool
$c>= :: Q_Q -> Q_Q -> Bool
> :: Q_Q -> Q_Q -> Bool
$c> :: Q_Q -> Q_Q -> Bool
<= :: Q_Q -> Q_Q -> Bool
$c<= :: Q_Q -> Q_Q -> Bool
< :: Q_Q -> Q_Q -> Bool
$c< :: Q_Q -> Q_Q -> Bool
compare :: Q_Q -> Q_Q -> Ordering
$ccompare :: Q_Q -> Q_Q -> Ordering
Ord, Int -> Q_Q -> ShowS
[Q_Q] -> ShowS
Q_Q -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Q_Q] -> ShowS
$cshowList :: [Q_Q] -> ShowS
show :: Q_Q -> String
$cshow :: Q_Q -> String
showsPrec :: Int -> Q_Q -> ShowS
$cshowsPrec :: Int -> Q_Q -> ShowS
Show, forall x. Rep Q_Q x -> Q_Q
forall x. Q_Q -> Rep Q_Q x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Q_Q x -> Q_Q
$cfrom :: forall x. Q_Q -> Rep Q_Q x
Generic)

class CQ x where
  _Q' ::
    Prism' x ()
  _Q ::
    x
  _Q =
    forall x. CQ x => Prism' x ()
_Q' forall t b. AReview t b -> b -> t
# ()

instance CQ () where
  _Q' :: Prism' () ()
_Q' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CQ Q_Q where
  _Q' :: Prism' Q_Q ()
_Q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Q_Q
Q_Q)
      (\Q_Q
Q_Q -> forall a. a -> Maybe a
Just ())

instance CQ Char where
  _Q' :: Prism' Char ()
_Q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'Q')
      (\Char
c ->  case Char
c of
                Char
'Q' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_Q ::
  (CQ x, CharParsing p) =>
  p x
parse_Q :: forall x (p :: * -> *). (CQ x, CharParsing p) => p x
parse_Q =
  forall x. CQ x => x
_Q forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'Q' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"Q"

data R_R =
  R_R
  deriving (R_R -> R_R -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: R_R -> R_R -> Bool
$c/= :: R_R -> R_R -> Bool
== :: R_R -> R_R -> Bool
$c== :: R_R -> R_R -> Bool
Eq, Eq R_R
R_R -> R_R -> Bool
R_R -> R_R -> Ordering
R_R -> R_R -> R_R
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: R_R -> R_R -> R_R
$cmin :: R_R -> R_R -> R_R
max :: R_R -> R_R -> R_R
$cmax :: R_R -> R_R -> R_R
>= :: R_R -> R_R -> Bool
$c>= :: R_R -> R_R -> Bool
> :: R_R -> R_R -> Bool
$c> :: R_R -> R_R -> Bool
<= :: R_R -> R_R -> Bool
$c<= :: R_R -> R_R -> Bool
< :: R_R -> R_R -> Bool
$c< :: R_R -> R_R -> Bool
compare :: R_R -> R_R -> Ordering
$ccompare :: R_R -> R_R -> Ordering
Ord, Int -> R_R -> ShowS
[R_R] -> ShowS
R_R -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [R_R] -> ShowS
$cshowList :: [R_R] -> ShowS
show :: R_R -> String
$cshow :: R_R -> String
showsPrec :: Int -> R_R -> ShowS
$cshowsPrec :: Int -> R_R -> ShowS
Show, forall x. Rep R_R x -> R_R
forall x. R_R -> Rep R_R x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep R_R x -> R_R
$cfrom :: forall x. R_R -> Rep R_R x
Generic)

class CR x where
  _R' ::
    Prism' x ()
  _R ::
    x
  _R =
    forall x. CR x => Prism' x ()
_R' forall t b. AReview t b -> b -> t
# ()

instance CR () where
  _R' :: Prism' () ()
_R' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CR R_R where
  _R' :: Prism' R_R ()
_R' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> R_R
R_R)
      (\R_R
R_R -> forall a. a -> Maybe a
Just ())

instance CR Char where
  _R' :: Prism' Char ()
_R' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'R')
      (\Char
c ->  case Char
c of
                Char
'R' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_R ::
  (CR x, CharParsing p) =>
  p x
parse_R :: forall x (p :: * -> *). (CR x, CharParsing p) => p x
parse_R =
  forall x. CR x => x
_R forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'R' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"R"

data S_S =
  S_S
  deriving (S_S -> S_S -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: S_S -> S_S -> Bool
$c/= :: S_S -> S_S -> Bool
== :: S_S -> S_S -> Bool
$c== :: S_S -> S_S -> Bool
Eq, Eq S_S
S_S -> S_S -> Bool
S_S -> S_S -> Ordering
S_S -> S_S -> S_S
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: S_S -> S_S -> S_S
$cmin :: S_S -> S_S -> S_S
max :: S_S -> S_S -> S_S
$cmax :: S_S -> S_S -> S_S
>= :: S_S -> S_S -> Bool
$c>= :: S_S -> S_S -> Bool
> :: S_S -> S_S -> Bool
$c> :: S_S -> S_S -> Bool
<= :: S_S -> S_S -> Bool
$c<= :: S_S -> S_S -> Bool
< :: S_S -> S_S -> Bool
$c< :: S_S -> S_S -> Bool
compare :: S_S -> S_S -> Ordering
$ccompare :: S_S -> S_S -> Ordering
Ord, Int -> S_S -> ShowS
[S_S] -> ShowS
S_S -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [S_S] -> ShowS
$cshowList :: [S_S] -> ShowS
show :: S_S -> String
$cshow :: S_S -> String
showsPrec :: Int -> S_S -> ShowS
$cshowsPrec :: Int -> S_S -> ShowS
Show, forall x. Rep S_S x -> S_S
forall x. S_S -> Rep S_S x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep S_S x -> S_S
$cfrom :: forall x. S_S -> Rep S_S x
Generic)

class CS x where
  _S' ::
    Prism' x ()
  _S ::
    x
  _S =
    forall x. CS x => Prism' x ()
_S' forall t b. AReview t b -> b -> t
# ()

instance CS () where
  _S' :: Prism' () ()
_S' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CS S_S where
  _S' :: Prism' S_S ()
_S' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> S_S
S_S)
      (\S_S
S_S -> forall a. a -> Maybe a
Just ())

instance CS Char where
  _S' :: Prism' Char ()
_S' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'S')
      (\Char
c ->  case Char
c of
                Char
'S' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_S ::
  (CS x, CharParsing p) =>
  p x
parse_S :: forall x (p :: * -> *). (CS x, CharParsing p) => p x
parse_S =
  forall x. CS x => x
_S forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'S' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"S"

data T_T =
  T_T
  deriving (T_T -> T_T -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: T_T -> T_T -> Bool
$c/= :: T_T -> T_T -> Bool
== :: T_T -> T_T -> Bool
$c== :: T_T -> T_T -> Bool
Eq, Eq T_T
T_T -> T_T -> Bool
T_T -> T_T -> Ordering
T_T -> T_T -> T_T
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: T_T -> T_T -> T_T
$cmin :: T_T -> T_T -> T_T
max :: T_T -> T_T -> T_T
$cmax :: T_T -> T_T -> T_T
>= :: T_T -> T_T -> Bool
$c>= :: T_T -> T_T -> Bool
> :: T_T -> T_T -> Bool
$c> :: T_T -> T_T -> Bool
<= :: T_T -> T_T -> Bool
$c<= :: T_T -> T_T -> Bool
< :: T_T -> T_T -> Bool
$c< :: T_T -> T_T -> Bool
compare :: T_T -> T_T -> Ordering
$ccompare :: T_T -> T_T -> Ordering
Ord, Int -> T_T -> ShowS
[T_T] -> ShowS
T_T -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [T_T] -> ShowS
$cshowList :: [T_T] -> ShowS
show :: T_T -> String
$cshow :: T_T -> String
showsPrec :: Int -> T_T -> ShowS
$cshowsPrec :: Int -> T_T -> ShowS
Show, forall x. Rep T_T x -> T_T
forall x. T_T -> Rep T_T x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep T_T x -> T_T
$cfrom :: forall x. T_T -> Rep T_T x
Generic)

class CT x where
  _T' ::
    Prism' x ()
  _T ::
    x
  _T =
    forall x. CT x => Prism' x ()
_T' forall t b. AReview t b -> b -> t
# ()

instance CT () where
  _T' :: Prism' () ()
_T' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CT T_T where
  _T' :: Prism' T_T ()
_T' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> T_T
T_T)
      (\T_T
T_T -> forall a. a -> Maybe a
Just ())

instance CT Char where
  _T' :: Prism' Char ()
_T' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'T')
      (\Char
c ->  case Char
c of
                Char
'T' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_T ::
  (CT x, CharParsing p) =>
  p x
parse_T :: forall x (p :: * -> *). (CT x, CharParsing p) => p x
parse_T =
  forall x. CT x => x
_T forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'T' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"T"

data U_U =
  U_U
  deriving (U_U -> U_U -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: U_U -> U_U -> Bool
$c/= :: U_U -> U_U -> Bool
== :: U_U -> U_U -> Bool
$c== :: U_U -> U_U -> Bool
Eq, Eq U_U
U_U -> U_U -> Bool
U_U -> U_U -> Ordering
U_U -> U_U -> U_U
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: U_U -> U_U -> U_U
$cmin :: U_U -> U_U -> U_U
max :: U_U -> U_U -> U_U
$cmax :: U_U -> U_U -> U_U
>= :: U_U -> U_U -> Bool
$c>= :: U_U -> U_U -> Bool
> :: U_U -> U_U -> Bool
$c> :: U_U -> U_U -> Bool
<= :: U_U -> U_U -> Bool
$c<= :: U_U -> U_U -> Bool
< :: U_U -> U_U -> Bool
$c< :: U_U -> U_U -> Bool
compare :: U_U -> U_U -> Ordering
$ccompare :: U_U -> U_U -> Ordering
Ord, Int -> U_U -> ShowS
[U_U] -> ShowS
U_U -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [U_U] -> ShowS
$cshowList :: [U_U] -> ShowS
show :: U_U -> String
$cshow :: U_U -> String
showsPrec :: Int -> U_U -> ShowS
$cshowsPrec :: Int -> U_U -> ShowS
Show, forall x. Rep U_U x -> U_U
forall x. U_U -> Rep U_U x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep U_U x -> U_U
$cfrom :: forall x. U_U -> Rep U_U x
Generic)

class CU x where
  _U' ::
    Prism' x ()
  _U ::
    x
  _U =
    forall x. CU x => Prism' x ()
_U' forall t b. AReview t b -> b -> t
# ()

instance CU () where
  _U' :: Prism' () ()
_U' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CU U_U where
  _U' :: Prism' U_U ()
_U' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> U_U
U_U)
      (\U_U
U_U -> forall a. a -> Maybe a
Just ())

instance CU Char where
  _U' :: Prism' Char ()
_U' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'U')
      (\Char
c ->  case Char
c of
                Char
'U' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_U ::
  (CU x, CharParsing p) =>
  p x
parse_U :: forall x (p :: * -> *). (CU x, CharParsing p) => p x
parse_U =
  forall x. CU x => x
_U forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'U' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"U"

data V_V =
  V_V
  deriving (V_V -> V_V -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: V_V -> V_V -> Bool
$c/= :: V_V -> V_V -> Bool
== :: V_V -> V_V -> Bool
$c== :: V_V -> V_V -> Bool
Eq, Eq V_V
V_V -> V_V -> Bool
V_V -> V_V -> Ordering
V_V -> V_V -> V_V
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: V_V -> V_V -> V_V
$cmin :: V_V -> V_V -> V_V
max :: V_V -> V_V -> V_V
$cmax :: V_V -> V_V -> V_V
>= :: V_V -> V_V -> Bool
$c>= :: V_V -> V_V -> Bool
> :: V_V -> V_V -> Bool
$c> :: V_V -> V_V -> Bool
<= :: V_V -> V_V -> Bool
$c<= :: V_V -> V_V -> Bool
< :: V_V -> V_V -> Bool
$c< :: V_V -> V_V -> Bool
compare :: V_V -> V_V -> Ordering
$ccompare :: V_V -> V_V -> Ordering
Ord, Int -> V_V -> ShowS
[V_V] -> ShowS
V_V -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [V_V] -> ShowS
$cshowList :: [V_V] -> ShowS
show :: V_V -> String
$cshow :: V_V -> String
showsPrec :: Int -> V_V -> ShowS
$cshowsPrec :: Int -> V_V -> ShowS
Show, forall x. Rep V_V x -> V_V
forall x. V_V -> Rep V_V x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep V_V x -> V_V
$cfrom :: forall x. V_V -> Rep V_V x
Generic)

class CV x where
  _V' ::
    Prism' x ()
  _V ::
    x
  _V =
    forall x. CV x => Prism' x ()
_V' forall t b. AReview t b -> b -> t
# ()

instance CV () where
  _V' :: Prism' () ()
_V' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CV V_V where
  _V' :: Prism' V_V ()
_V' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> V_V
V_V)
      (\V_V
V_V -> forall a. a -> Maybe a
Just ())

instance CV Char where
  _V' :: Prism' Char ()
_V' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'V')
      (\Char
c ->  case Char
c of
                Char
'V' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_V ::
  (CV x, CharParsing p) =>
  p x
parse_V :: forall x (p :: * -> *). (CV x, CharParsing p) => p x
parse_V =
  forall x. CV x => x
_V forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'V' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"V"

data W_W =
  W_W
  deriving (W_W -> W_W -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: W_W -> W_W -> Bool
$c/= :: W_W -> W_W -> Bool
== :: W_W -> W_W -> Bool
$c== :: W_W -> W_W -> Bool
Eq, Eq W_W
W_W -> W_W -> Bool
W_W -> W_W -> Ordering
W_W -> W_W -> W_W
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: W_W -> W_W -> W_W
$cmin :: W_W -> W_W -> W_W
max :: W_W -> W_W -> W_W
$cmax :: W_W -> W_W -> W_W
>= :: W_W -> W_W -> Bool
$c>= :: W_W -> W_W -> Bool
> :: W_W -> W_W -> Bool
$c> :: W_W -> W_W -> Bool
<= :: W_W -> W_W -> Bool
$c<= :: W_W -> W_W -> Bool
< :: W_W -> W_W -> Bool
$c< :: W_W -> W_W -> Bool
compare :: W_W -> W_W -> Ordering
$ccompare :: W_W -> W_W -> Ordering
Ord, Int -> W_W -> ShowS
[W_W] -> ShowS
W_W -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [W_W] -> ShowS
$cshowList :: [W_W] -> ShowS
show :: W_W -> String
$cshow :: W_W -> String
showsPrec :: Int -> W_W -> ShowS
$cshowsPrec :: Int -> W_W -> ShowS
Show, forall x. Rep W_W x -> W_W
forall x. W_W -> Rep W_W x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep W_W x -> W_W
$cfrom :: forall x. W_W -> Rep W_W x
Generic)

class CW x where
  _W' ::
    Prism' x ()
  _W ::
    x
  _W =
    forall x. CW x => Prism' x ()
_W' forall t b. AReview t b -> b -> t
# ()

instance CW () where
  _W' :: Prism' () ()
_W' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CW W_W where
  _W' :: Prism' W_W ()
_W' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> W_W
W_W)
      (\W_W
W_W -> forall a. a -> Maybe a
Just ())

instance CW Char where
  _W' :: Prism' Char ()
_W' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'W')
      (\Char
c ->  case Char
c of
                Char
'W' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_W ::
  (CW x, CharParsing p) =>
  p x
parse_W :: forall x (p :: * -> *). (CW x, CharParsing p) => p x
parse_W =
  forall x. CW x => x
_W forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'W' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"W"

data X_X =
  X_X
  deriving (X_X -> X_X -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: X_X -> X_X -> Bool
$c/= :: X_X -> X_X -> Bool
== :: X_X -> X_X -> Bool
$c== :: X_X -> X_X -> Bool
Eq, Eq X_X
X_X -> X_X -> Bool
X_X -> X_X -> Ordering
X_X -> X_X -> X_X
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: X_X -> X_X -> X_X
$cmin :: X_X -> X_X -> X_X
max :: X_X -> X_X -> X_X
$cmax :: X_X -> X_X -> X_X
>= :: X_X -> X_X -> Bool
$c>= :: X_X -> X_X -> Bool
> :: X_X -> X_X -> Bool
$c> :: X_X -> X_X -> Bool
<= :: X_X -> X_X -> Bool
$c<= :: X_X -> X_X -> Bool
< :: X_X -> X_X -> Bool
$c< :: X_X -> X_X -> Bool
compare :: X_X -> X_X -> Ordering
$ccompare :: X_X -> X_X -> Ordering
Ord, Int -> X_X -> ShowS
[X_X] -> ShowS
X_X -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [X_X] -> ShowS
$cshowList :: [X_X] -> ShowS
show :: X_X -> String
$cshow :: X_X -> String
showsPrec :: Int -> X_X -> ShowS
$cshowsPrec :: Int -> X_X -> ShowS
Show, forall x. Rep X_X x -> X_X
forall x. X_X -> Rep X_X x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep X_X x -> X_X
$cfrom :: forall x. X_X -> Rep X_X x
Generic)

class CX x where
  _X' ::
    Prism' x ()
  _X ::
    x
  _X =
    forall x. CX x => Prism' x ()
_X' forall t b. AReview t b -> b -> t
# ()

instance CX () where
  _X' :: Prism' () ()
_X' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CX X_X where
  _X' :: Prism' X_X ()
_X' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> X_X
X_X)
      (\X_X
X_X -> forall a. a -> Maybe a
Just ())

instance CX Char where
  _X' :: Prism' Char ()
_X' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'X')
      (\Char
c ->  case Char
c of
                Char
'X' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_X ::
  (CX x, CharParsing p) =>
  p x
parse_X :: forall x (p :: * -> *). (CX x, CharParsing p) => p x
parse_X =
  forall x. CX x => x
_X forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'X' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"X"

data Y_Y =
  Y_Y
  deriving (Y_Y -> Y_Y -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Y_Y -> Y_Y -> Bool
$c/= :: Y_Y -> Y_Y -> Bool
== :: Y_Y -> Y_Y -> Bool
$c== :: Y_Y -> Y_Y -> Bool
Eq, Eq Y_Y
Y_Y -> Y_Y -> Bool
Y_Y -> Y_Y -> Ordering
Y_Y -> Y_Y -> Y_Y
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Y_Y -> Y_Y -> Y_Y
$cmin :: Y_Y -> Y_Y -> Y_Y
max :: Y_Y -> Y_Y -> Y_Y
$cmax :: Y_Y -> Y_Y -> Y_Y
>= :: Y_Y -> Y_Y -> Bool
$c>= :: Y_Y -> Y_Y -> Bool
> :: Y_Y -> Y_Y -> Bool
$c> :: Y_Y -> Y_Y -> Bool
<= :: Y_Y -> Y_Y -> Bool
$c<= :: Y_Y -> Y_Y -> Bool
< :: Y_Y -> Y_Y -> Bool
$c< :: Y_Y -> Y_Y -> Bool
compare :: Y_Y -> Y_Y -> Ordering
$ccompare :: Y_Y -> Y_Y -> Ordering
Ord, Int -> Y_Y -> ShowS
[Y_Y] -> ShowS
Y_Y -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Y_Y] -> ShowS
$cshowList :: [Y_Y] -> ShowS
show :: Y_Y -> String
$cshow :: Y_Y -> String
showsPrec :: Int -> Y_Y -> ShowS
$cshowsPrec :: Int -> Y_Y -> ShowS
Show, forall x. Rep Y_Y x -> Y_Y
forall x. Y_Y -> Rep Y_Y x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Y_Y x -> Y_Y
$cfrom :: forall x. Y_Y -> Rep Y_Y x
Generic)

class CY x where
  _Y' ::
    Prism' x ()
  _Y ::
    x
  _Y =
    forall x. CY x => Prism' x ()
_Y' forall t b. AReview t b -> b -> t
# ()

instance CY () where
  _Y' :: Prism' () ()
_Y' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CY Y_Y where
  _Y' :: Prism' Y_Y ()
_Y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Y_Y
Y_Y)
      (\Y_Y
Y_Y -> forall a. a -> Maybe a
Just ())

instance CY Char where
  _Y' :: Prism' Char ()
_Y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'Y')
      (\Char
c ->  case Char
c of
                Char
'Y' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_Y ::
  (CY x, CharParsing p) =>
  p x
parse_Y :: forall x (p :: * -> *). (CY x, CharParsing p) => p x
parse_Y =
  forall x. CY x => x
_Y forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'Y' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"Y"

data Z_Z =
  Z_Z
  deriving (Z_Z -> Z_Z -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Z_Z -> Z_Z -> Bool
$c/= :: Z_Z -> Z_Z -> Bool
== :: Z_Z -> Z_Z -> Bool
$c== :: Z_Z -> Z_Z -> Bool
Eq, Eq Z_Z
Z_Z -> Z_Z -> Bool
Z_Z -> Z_Z -> Ordering
Z_Z -> Z_Z -> Z_Z
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Z_Z -> Z_Z -> Z_Z
$cmin :: Z_Z -> Z_Z -> Z_Z
max :: Z_Z -> Z_Z -> Z_Z
$cmax :: Z_Z -> Z_Z -> Z_Z
>= :: Z_Z -> Z_Z -> Bool
$c>= :: Z_Z -> Z_Z -> Bool
> :: Z_Z -> Z_Z -> Bool
$c> :: Z_Z -> Z_Z -> Bool
<= :: Z_Z -> Z_Z -> Bool
$c<= :: Z_Z -> Z_Z -> Bool
< :: Z_Z -> Z_Z -> Bool
$c< :: Z_Z -> Z_Z -> Bool
compare :: Z_Z -> Z_Z -> Ordering
$ccompare :: Z_Z -> Z_Z -> Ordering
Ord, Int -> Z_Z -> ShowS
[Z_Z] -> ShowS
Z_Z -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Z_Z] -> ShowS
$cshowList :: [Z_Z] -> ShowS
show :: Z_Z -> String
$cshow :: Z_Z -> String
showsPrec :: Int -> Z_Z -> ShowS
$cshowsPrec :: Int -> Z_Z -> ShowS
Show, forall x. Rep Z_Z x -> Z_Z
forall x. Z_Z -> Rep Z_Z x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Z_Z x -> Z_Z
$cfrom :: forall x. Z_Z -> Rep Z_Z x
Generic)

class CZ x where
  _Z' ::
    Prism' x ()
  _Z ::
    x
  _Z =
    forall x. CZ x => Prism' x ()
_Z' forall t b. AReview t b -> b -> t
# ()

instance CZ () where
  _Z' :: Prism' () ()
_Z' =
    forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id

instance CZ Z_Z where
  _Z' :: Prism' Z_Z ()
_Z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Z_Z
Z_Z)
      (\Z_Z
Z_Z -> forall a. a -> Maybe a
Just ())

instance CZ Char where
  _Z' :: Prism' Char ()
_Z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Char
'Z')
      (\Char
c ->  case Char
c of
                Char
'Z' ->
                  forall a. a -> Maybe a
Just ()
                Char
_ ->
                  forall a. Maybe a
Nothing)

parse_Z ::
  (CZ x, CharParsing p) =>
  p x
parse_Z :: forall x (p :: * -> *). (CZ x, CharParsing p) => p x
parse_Z =
  forall x. CZ x => x
_Z forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'Z' forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"Z"

----

type IsLower x =
  (
    Ca x
  , Cb x
  , Cc x
  , Cd x
  , Ce x
  , Cf x
  , Cg x
  , Ch x
  , Ci x
  , Cj x
  , Ck x
  , Cl x
  , Cm x
  , Cn x
  , Co x
  , Cp x
  , Cq x
  , Cr x
  , Cs x
  , Ct x
  , Cu x
  , Cv x
  , Cw x
  , Cx x
  , Cy x
  , Cz x
  )

data Lower =
  Lower_a
  | Lower_b
  | Lower_c
  | Lower_d
  | Lower_e
  | Lower_f
  | Lower_g
  | Lower_h
  | Lower_i
  | Lower_j
  | Lower_k
  | Lower_l
  | Lower_m
  | Lower_n
  | Lower_o
  | Lower_p
  | Lower_q
  | Lower_r
  | Lower_s
  | Lower_t
  | Lower_u
  | Lower_v
  | Lower_w
  | Lower_x
  | Lower_y
  | Lower_z
  deriving (Lower -> Lower -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lower -> Lower -> Bool
$c/= :: Lower -> Lower -> Bool
== :: Lower -> Lower -> Bool
$c== :: Lower -> Lower -> Bool
Eq, Eq Lower
Lower -> Lower -> Bool
Lower -> Lower -> Ordering
Lower -> Lower -> Lower
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Lower -> Lower -> Lower
$cmin :: Lower -> Lower -> Lower
max :: Lower -> Lower -> Lower
$cmax :: Lower -> Lower -> Lower
>= :: Lower -> Lower -> Bool
$c>= :: Lower -> Lower -> Bool
> :: Lower -> Lower -> Bool
$c> :: Lower -> Lower -> Bool
<= :: Lower -> Lower -> Bool
$c<= :: Lower -> Lower -> Bool
< :: Lower -> Lower -> Bool
$c< :: Lower -> Lower -> Bool
compare :: Lower -> Lower -> Ordering
$ccompare :: Lower -> Lower -> Ordering
Ord, Int -> Lower -> ShowS
[Lower] -> ShowS
Lower -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lower] -> ShowS
$cshowList :: [Lower] -> ShowS
show :: Lower -> String
$cshow :: Lower -> String
showsPrec :: Int -> Lower -> ShowS
$cshowsPrec :: Int -> Lower -> ShowS
Show, forall x. Rep Lower x -> Lower
forall x. Lower -> Rep Lower x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Lower x -> Lower
$cfrom :: forall x. Lower -> Rep Lower x
Generic)

instance Ca Lower where
  _a' :: Prism' Lower ()
_a' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_a)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_a ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cb Lower where
  _b' :: Prism' Lower ()
_b' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_b)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_b ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cc Lower where
  _c' :: Prism' Lower ()
_c' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_c)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_c ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cd Lower where
  _d' :: Prism' Lower ()
_d' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_d)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_d ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Ce Lower where
  _e' :: Prism' Lower ()
_e' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_e)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_e ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cf Lower where
  _f' :: Prism' Lower ()
_f' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_f)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_f ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cg Lower where
  _g' :: Prism' Lower ()
_g' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_g)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_g ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Ch Lower where
  _h' :: Prism' Lower ()
_h' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_h)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_h ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Ci Lower where
  _i' :: Prism' Lower ()
_i' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_i)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_i ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cj Lower where
  _j' :: Prism' Lower ()
_j' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_j)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_j ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Ck Lower where
  _k' :: Prism' Lower ()
_k' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_k)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_k ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cl Lower where
  _l' :: Prism' Lower ()
_l' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_l)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_l ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cm Lower where
  _m' :: Prism' Lower ()
_m' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_m)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_m ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cn Lower where
  _n' :: Prism' Lower ()
_n' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_n)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_n ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Co Lower where
  _o' :: Prism' Lower ()
_o' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_o)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_o ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cp Lower where
  _p' :: Prism' Lower ()
_p' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_p)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_p ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cq Lower where
  _q' :: Prism' Lower ()
_q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_q)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_q ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cr Lower where
  _r' :: Prism' Lower ()
_r' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_r)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_r ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cs Lower where
  _s' :: Prism' Lower ()
_s' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_s)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_s ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Ct Lower where
  _t' :: Prism' Lower ()
_t' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_t)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_t ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cu Lower where
  _u' :: Prism' Lower ()
_u' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_u)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_u ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cv Lower where
  _v' :: Prism' Lower ()
_v' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_v)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_v ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cw Lower where
  _w' :: Prism' Lower ()
_w' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_w)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_w ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cx Lower where
  _x' :: Prism' Lower ()
_x' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_x)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_x ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cy Lower where
  _y' :: Prism' Lower ()
_y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_y)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_y ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

instance Cz Lower where
  _z' :: Prism' Lower ()
_z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Lower
Lower_z)
      (\Lower
c ->  case Lower
c of
                Lower
Lower_z ->
                  forall a. a -> Maybe a
Just ()
                Lower
_ ->
                  forall a. Maybe a
Nothing)

parse_lower ::
  (IsLower x, CharParsing p) =>
  p x
parse_lower :: forall x (p :: * -> *). (IsLower x, CharParsing p) => p x
parse_lower =
  forall x (p :: * -> *). (Ca x, CharParsing p) => p x
parse_a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cb x, CharParsing p) => p x
parse_b forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cc x, CharParsing p) => p x
parse_c forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cd x, CharParsing p) => p x
parse_d forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Ce x, CharParsing p) => p x
parse_e forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cf x, CharParsing p) => p x
parse_f forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cg x, CharParsing p) => p x
parse_g forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Ch x, CharParsing p) => p x
parse_h forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Ci x, CharParsing p) => p x
parse_i forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cj x, CharParsing p) => p x
parse_j forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Ck x, CharParsing p) => p x
parse_k forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cl x, CharParsing p) => p x
parse_l forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cm x, CharParsing p) => p x
parse_m forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cn x, CharParsing p) => p x
parse_n forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Co x, CharParsing p) => p x
parse_o forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cp x, CharParsing p) => p x
parse_p forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cq x, CharParsing p) => p x
parse_q forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cr x, CharParsing p) => p x
parse_r forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cs x, CharParsing p) => p x
parse_s forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Ct x, CharParsing p) => p x
parse_t forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cu x, CharParsing p) => p x
parse_u forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cv x, CharParsing p) => p x
parse_v forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cw x, CharParsing p) => p x
parse_w forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cx x, CharParsing p) => p x
parse_x forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cy x, CharParsing p) => p x
parse_y forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (Cz x, CharParsing p) => p x
parse_z

type IsUpper x =
  (
    CA x
  , CB x
  , CC x
  , CD x
  , CE x
  , CF x
  , CG x
  , CH x
  , CI x
  , CJ x
  , CK x
  , CL x
  , CM x
  , CN x
  , CO x
  , CP x
  , CQ x
  , CR x
  , CS x
  , CT x
  , CU x
  , CV x
  , CW x
  , CX x
  , CY x
  , CZ x
  )

data Upper =
  Upper_A
  | Upper_B
  | Upper_C
  | Upper_D
  | Upper_E
  | Upper_F
  | Upper_G
  | Upper_H
  | Upper_I
  | Upper_J
  | Upper_K
  | Upper_L
  | Upper_M
  | Upper_N
  | Upper_O
  | Upper_P
  | Upper_Q
  | Upper_R
  | Upper_S
  | Upper_T
  | Upper_U
  | Upper_V
  | Upper_W
  | Upper_X
  | Upper_Y
  | Upper_Z
  deriving (Upper -> Upper -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Upper -> Upper -> Bool
$c/= :: Upper -> Upper -> Bool
== :: Upper -> Upper -> Bool
$c== :: Upper -> Upper -> Bool
Eq, Eq Upper
Upper -> Upper -> Bool
Upper -> Upper -> Ordering
Upper -> Upper -> Upper
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Upper -> Upper -> Upper
$cmin :: Upper -> Upper -> Upper
max :: Upper -> Upper -> Upper
$cmax :: Upper -> Upper -> Upper
>= :: Upper -> Upper -> Bool
$c>= :: Upper -> Upper -> Bool
> :: Upper -> Upper -> Bool
$c> :: Upper -> Upper -> Bool
<= :: Upper -> Upper -> Bool
$c<= :: Upper -> Upper -> Bool
< :: Upper -> Upper -> Bool
$c< :: Upper -> Upper -> Bool
compare :: Upper -> Upper -> Ordering
$ccompare :: Upper -> Upper -> Ordering
Ord, Int -> Upper -> ShowS
[Upper] -> ShowS
Upper -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Upper] -> ShowS
$cshowList :: [Upper] -> ShowS
show :: Upper -> String
$cshow :: Upper -> String
showsPrec :: Int -> Upper -> ShowS
$cshowsPrec :: Int -> Upper -> ShowS
Show, forall x. Rep Upper x -> Upper
forall x. Upper -> Rep Upper x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Upper x -> Upper
$cfrom :: forall x. Upper -> Rep Upper x
Generic)

instance CA Upper where
  _A' :: Prism' Upper ()
_A' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_A)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_A ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CB Upper where
  _B' :: Prism' Upper ()
_B' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_B)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_B ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CC Upper where
  _C' :: Prism' Upper ()
_C' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_C)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_C ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CD Upper where
  _D' :: Prism' Upper ()
_D' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_D)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_D ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CE Upper where
  _E' :: Prism' Upper ()
_E' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_E)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_E ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CF Upper where
  _F' :: Prism' Upper ()
_F' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_F)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_F ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CG Upper where
  _G' :: Prism' Upper ()
_G' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_G)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_G ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CH Upper where
  _H' :: Prism' Upper ()
_H' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_H)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_H ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CI Upper where
  _I' :: Prism' Upper ()
_I' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_I)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_I ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CJ Upper where
  _J' :: Prism' Upper ()
_J' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_J)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_J ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CK Upper where
  _K' :: Prism' Upper ()
_K' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_K)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_K ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CL Upper where
  _L' :: Prism' Upper ()
_L' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_L)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_L ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CM Upper where
  _M' :: Prism' Upper ()
_M' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_M)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_M ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CN Upper where
  _N' :: Prism' Upper ()
_N' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_N)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_N ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CO Upper where
  _O' :: Prism' Upper ()
_O' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_O)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_O ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CP Upper where
  _P' :: Prism' Upper ()
_P' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_P)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_P ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CQ Upper where
  _Q' :: Prism' Upper ()
_Q' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_Q)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_Q ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CR Upper where
  _R' :: Prism' Upper ()
_R' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_R)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_R ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CS Upper where
  _S' :: Prism' Upper ()
_S' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_S)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_S ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CT Upper where
  _T' :: Prism' Upper ()
_T' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_T)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_T ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CU Upper where
  _U' :: Prism' Upper ()
_U' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_U)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_U ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CV Upper where
  _V' :: Prism' Upper ()
_V' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_V)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_V ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CW Upper where
  _W' :: Prism' Upper ()
_W' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_W)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_W ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CX Upper where
  _X' :: Prism' Upper ()
_X' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_X)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_X ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CY Upper where
  _Y' :: Prism' Upper ()
_Y' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_Y)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_Y ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

instance CZ Upper where
  _Z' :: Prism' Upper ()
_Z' =
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
      (\() -> Upper
Upper_Z)
      (\Upper
c ->  case Upper
c of
                Upper
Upper_Z ->
                  forall a. a -> Maybe a
Just ()
                Upper
_ ->
                  forall a. Maybe a
Nothing)

parse_upper ::
  (IsUpper x, CharParsing p) =>
  p x
parse_upper :: forall x (p :: * -> *). (IsUpper x, CharParsing p) => p x
parse_upper =
  forall x (p :: * -> *). (CA x, CharParsing p) => p x
parse_A forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CB x, CharParsing p) => p x
parse_B forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CC x, CharParsing p) => p x
parse_C forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CD x, CharParsing p) => p x
parse_D forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CE x, CharParsing p) => p x
parse_E forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CF x, CharParsing p) => p x
parse_F forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CG x, CharParsing p) => p x
parse_G forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CH x, CharParsing p) => p x
parse_H forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CI x, CharParsing p) => p x
parse_I forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CJ x, CharParsing p) => p x
parse_J forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CK x, CharParsing p) => p x
parse_K forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CL x, CharParsing p) => p x
parse_L forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CM x, CharParsing p) => p x
parse_M forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CN x, CharParsing p) => p x
parse_N forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CO x, CharParsing p) => p x
parse_O forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CP x, CharParsing p) => p x
parse_P forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CQ x, CharParsing p) => p x
parse_Q forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CR x, CharParsing p) => p x
parse_R forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CS x, CharParsing p) => p x
parse_S forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CT x, CharParsing p) => p x
parse_T forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CU x, CharParsing p) => p x
parse_U forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CV x, CharParsing p) => p x
parse_V forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CW x, CharParsing p) => p x
parse_W forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CX x, CharParsing p) => p x
parse_X forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CY x, CharParsing p) => p x
parse_Y forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (CZ x, CharParsing p) => p x
parse_Z

type IsAlpha x =
  (
    IsLower x
  , IsUpper x
  )

data Alpha =
  AlphaLower Lower
  | AlphaUpper Upper
  deriving (Alpha -> Alpha -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Alpha -> Alpha -> Bool
$c/= :: Alpha -> Alpha -> Bool
== :: Alpha -> Alpha -> Bool
$c== :: Alpha -> Alpha -> Bool
Eq, Eq Alpha
Alpha -> Alpha -> Bool
Alpha -> Alpha -> Ordering
Alpha -> Alpha -> Alpha
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Alpha -> Alpha -> Alpha
$cmin :: Alpha -> Alpha -> Alpha
max :: Alpha -> Alpha -> Alpha
$cmax :: Alpha -> Alpha -> Alpha
>= :: Alpha -> Alpha -> Bool
$c>= :: Alpha -> Alpha -> Bool
> :: Alpha -> Alpha -> Bool
$c> :: Alpha -> Alpha -> Bool
<= :: Alpha -> Alpha -> Bool
$c<= :: Alpha -> Alpha -> Bool
< :: Alpha -> Alpha -> Bool
$c< :: Alpha -> Alpha -> Bool
compare :: Alpha -> Alpha -> Ordering
$ccompare :: Alpha -> Alpha -> Ordering
Ord, Int -> Alpha -> ShowS
[Alpha] -> ShowS
Alpha -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Alpha] -> ShowS
$cshowList :: [Alpha] -> ShowS
show :: Alpha -> String
$cshow :: Alpha -> String
showsPrec :: Int -> Alpha -> ShowS
$cshowsPrec :: Int -> Alpha -> ShowS
Show, forall x. Rep Alpha x -> Alpha
forall x. Alpha -> Rep Alpha x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Alpha x -> Alpha
$cfrom :: forall x. Alpha -> Rep Alpha x
Generic)

_AlphaLower ::
  Prism'
    Alpha
    Lower
_AlphaLower :: Prism' Alpha Lower
_AlphaLower =
  forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    Lower -> Alpha
AlphaLower    
    (\Alpha
c ->  case Alpha
c of
              AlphaLower Lower
l ->
                forall a. a -> Maybe a
Just Lower
l
              AlphaUpper Upper
_ ->
                forall a. Maybe a
Nothing)

_AlphaUpper ::
  Prism'
    Alpha
    Upper
_AlphaUpper :: Prism' Alpha Upper
_AlphaUpper =
  forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    Upper -> Alpha
AlphaUpper    
    (\Alpha
c ->  case Alpha
c of
              AlphaUpper Upper
l ->
                forall a. a -> Maybe a
Just Upper
l
              AlphaLower Lower
_ ->
                forall a. Maybe a
Nothing)
instance Ca Alpha where
  _a' :: Prism' Alpha ()
_a' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ca x => Prism' x ()
_a'


instance Cb Alpha where
  _b' :: Prism' Alpha ()
_b' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cb x => Prism' x ()
_b'


instance Cc Alpha where
  _c' :: Prism' Alpha ()
_c' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cc x => Prism' x ()
_c'


instance Cd Alpha where
  _d' :: Prism' Alpha ()
_d' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cd x => Prism' x ()
_d'


instance Ce Alpha where
  _e' :: Prism' Alpha ()
_e' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ce x => Prism' x ()
_e'


instance Cf Alpha where
  _f' :: Prism' Alpha ()
_f' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cf x => Prism' x ()
_f'


instance Cg Alpha where
  _g' :: Prism' Alpha ()
_g' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cg x => Prism' x ()
_g'


instance Ch Alpha where
  _h' :: Prism' Alpha ()
_h' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ch x => Prism' x ()
_h'


instance Ci Alpha where
  _i' :: Prism' Alpha ()
_i' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ci x => Prism' x ()
_i'


instance Cj Alpha where
  _j' :: Prism' Alpha ()
_j' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cj x => Prism' x ()
_j'


instance Ck Alpha where
  _k' :: Prism' Alpha ()
_k' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ck x => Prism' x ()
_k'


instance Cl Alpha where
  _l' :: Prism' Alpha ()
_l' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cl x => Prism' x ()
_l'


instance Cm Alpha where
  _m' :: Prism' Alpha ()
_m' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cm x => Prism' x ()
_m'


instance Cn Alpha where
  _n' :: Prism' Alpha ()
_n' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cn x => Prism' x ()
_n'


instance Co Alpha where
  _o' :: Prism' Alpha ()
_o' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Co x => Prism' x ()
_o'


instance Cp Alpha where
  _p' :: Prism' Alpha ()
_p' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cp x => Prism' x ()
_p'


instance Cq Alpha where
  _q' :: Prism' Alpha ()
_q' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cq x => Prism' x ()
_q'


instance Cr Alpha where
  _r' :: Prism' Alpha ()
_r' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cr x => Prism' x ()
_r'


instance Cs Alpha where
  _s' :: Prism' Alpha ()
_s' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cs x => Prism' x ()
_s'


instance Ct Alpha where
  _t' :: Prism' Alpha ()
_t' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Ct x => Prism' x ()
_t'


instance Cu Alpha where
  _u' :: Prism' Alpha ()
_u' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cu x => Prism' x ()
_u'


instance Cv Alpha where
  _v' :: Prism' Alpha ()
_v' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cv x => Prism' x ()
_v'


instance Cw Alpha where
  _w' :: Prism' Alpha ()
_w' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cw x => Prism' x ()
_w'


instance Cx Alpha where
  _x' :: Prism' Alpha ()
_x' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cx x => Prism' x ()
_x'


instance Cy Alpha where
  _y' :: Prism' Alpha ()
_y' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cy x => Prism' x ()
_y'


instance Cz Alpha where
  _z' :: Prism' Alpha ()
_z' =
    Prism' Alpha Lower
_AlphaLower forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. Cz x => Prism' x ()
_z'

instance CA Alpha where
  _A' :: Prism' Alpha ()
_A' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CA x => Prism' x ()
_A'


instance CB Alpha where
  _B' :: Prism' Alpha ()
_B' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CB x => Prism' x ()
_B'


instance CC Alpha where
  _C' :: Prism' Alpha ()
_C' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CC x => Prism' x ()
_C'


instance CD Alpha where
  _D' :: Prism' Alpha ()
_D' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CD x => Prism' x ()
_D'


instance CE Alpha where
  _E' :: Prism' Alpha ()
_E' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CE x => Prism' x ()
_E'


instance CF Alpha where
  _F' :: Prism' Alpha ()
_F' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CF x => Prism' x ()
_F'


instance CG Alpha where
  _G' :: Prism' Alpha ()
_G' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CG x => Prism' x ()
_G'


instance CH Alpha where
  _H' :: Prism' Alpha ()
_H' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CH x => Prism' x ()
_H'


instance CI Alpha where
  _I' :: Prism' Alpha ()
_I' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CI x => Prism' x ()
_I'


instance CJ Alpha where
  _J' :: Prism' Alpha ()
_J' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CJ x => Prism' x ()
_J'


instance CK Alpha where
  _K' :: Prism' Alpha ()
_K' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CK x => Prism' x ()
_K'


instance CL Alpha where
  _L' :: Prism' Alpha ()
_L' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CL x => Prism' x ()
_L'


instance CM Alpha where
  _M' :: Prism' Alpha ()
_M' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CM x => Prism' x ()
_M'


instance CN Alpha where
  _N' :: Prism' Alpha ()
_N' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CN x => Prism' x ()
_N'


instance CO Alpha where
  _O' :: Prism' Alpha ()
_O' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CO x => Prism' x ()
_O'


instance CP Alpha where
  _P' :: Prism' Alpha ()
_P' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CP x => Prism' x ()
_P'


instance CQ Alpha where
  _Q' :: Prism' Alpha ()
_Q' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CQ x => Prism' x ()
_Q'


instance CR Alpha where
  _R' :: Prism' Alpha ()
_R' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CR x => Prism' x ()
_R'


instance CS Alpha where
  _S' :: Prism' Alpha ()
_S' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CS x => Prism' x ()
_S'


instance CT Alpha where
  _T' :: Prism' Alpha ()
_T' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CT x => Prism' x ()
_T'


instance CU Alpha where
  _U' :: Prism' Alpha ()
_U' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CU x => Prism' x ()
_U'


instance CV Alpha where
  _V' :: Prism' Alpha ()
_V' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CV x => Prism' x ()
_V'


instance CW Alpha where
  _W' :: Prism' Alpha ()
_W' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CW x => Prism' x ()
_W'


instance CX Alpha where
  _X' :: Prism' Alpha ()
_X' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CX x => Prism' x ()
_X'


instance CY Alpha where
  _Y' :: Prism' Alpha ()
_Y' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CY x => Prism' x ()
_Y'


instance CZ Alpha where
  _Z' :: Prism' Alpha ()
_Z' =
    Prism' Alpha Upper
_AlphaUpper forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall x. CZ x => Prism' x ()
_Z'

parse_alpha ::
  (IsAlpha x, CharParsing p) =>
  p x
parse_alpha :: forall x (p :: * -> *). (IsAlpha x, CharParsing p) => p x
parse_alpha =
  forall x (p :: * -> *). (IsLower x, CharParsing p) => p x
parse_lower forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall x (p :: * -> *). (IsUpper x, CharParsing p) => p x
parse_upper

lookup1 ::
  Eq a =>
  a
  -> NonEmpty (a, b)
  -> b
lookup1 :: forall a b. Eq a => a -> NonEmpty (a, b) -> b
lookup1 a
a ((a
_, b
q) :| [(a, b)]
t) =
  forall a. a -> Maybe a -> a
fromMaybe b
q (forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup a
a [(a, b)]
t)

lower_upper ::
  Iso'
    Lower
    Upper
lower_upper :: Iso' Lower Upper
lower_upper =
  let r :: NonEmpty (Lower, Upper)
r =
        (Lower
Lower_a, Upper
Upper_A) forall a. a -> [a] -> NonEmpty a
:|
        [
          (Lower
Lower_b, Upper
Upper_B)
        , (Lower
Lower_c, Upper
Upper_C)
        , (Lower
Lower_d, Upper
Upper_D)
        , (Lower
Lower_e, Upper
Upper_E)
        , (Lower
Lower_f, Upper
Upper_F)
        , (Lower
Lower_g, Upper
Upper_G)
        , (Lower
Lower_h, Upper
Upper_H)
        , (Lower
Lower_i, Upper
Upper_I)
        , (Lower
Lower_j, Upper
Upper_J)
        , (Lower
Lower_k, Upper
Upper_K)
        , (Lower
Lower_l, Upper
Upper_L)
        , (Lower
Lower_m, Upper
Upper_M)
        , (Lower
Lower_n, Upper
Upper_N)
        , (Lower
Lower_o, Upper
Upper_O)
        , (Lower
Lower_p, Upper
Upper_P)
        , (Lower
Lower_q, Upper
Upper_Q)
        , (Lower
Lower_r, Upper
Upper_R)
        , (Lower
Lower_s, Upper
Upper_S)
        , (Lower
Lower_t, Upper
Upper_T)
        , (Lower
Lower_u, Upper
Upper_U)
        , (Lower
Lower_v, Upper
Upper_V)
        , (Lower
Lower_w, Upper
Upper_W)
        , (Lower
Lower_x, Upper
Upper_X)
        , (Lower
Lower_y, Upper
Upper_Y)
        , (Lower
Lower_z, Upper
Upper_Z)
        ]
  in  forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` NonEmpty (Lower, Upper)
r)
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` ((\(Lower
m, Upper
n) -> (Upper
n, Lower
m)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (Lower, Upper)
r))

upper_lower ::
  Iso'
    Upper
    Lower
upper_lower :: Iso' Upper Lower
upper_lower =
  forall s t a b. AnIso s t a b -> Iso b a t s
from Iso' Lower Upper
lower_upper

rotate1_lower ::
  Iso'
    Lower
    Lower
rotate1_lower :: Iso' Lower Lower
rotate1_lower =
  let r :: NonEmpty (Lower, Lower)
r =
        (Lower
Lower_a, Lower
Lower_b) forall a. a -> [a] -> NonEmpty a
:|
        [
          (Lower
Lower_b, Lower
Lower_c)
        , (Lower
Lower_c, Lower
Lower_d)
        , (Lower
Lower_d, Lower
Lower_e)
        , (Lower
Lower_e, Lower
Lower_f)
        , (Lower
Lower_f, Lower
Lower_g)
        , (Lower
Lower_g, Lower
Lower_h)
        , (Lower
Lower_h, Lower
Lower_i)
        , (Lower
Lower_i, Lower
Lower_j)
        , (Lower
Lower_j, Lower
Lower_k)
        , (Lower
Lower_k, Lower
Lower_l)
        , (Lower
Lower_l, Lower
Lower_m)
        , (Lower
Lower_m, Lower
Lower_n)
        , (Lower
Lower_n, Lower
Lower_o)
        , (Lower
Lower_o, Lower
Lower_p)
        , (Lower
Lower_p, Lower
Lower_q)
        , (Lower
Lower_q, Lower
Lower_r)
        , (Lower
Lower_r, Lower
Lower_s)
        , (Lower
Lower_s, Lower
Lower_t)
        , (Lower
Lower_t, Lower
Lower_u)
        , (Lower
Lower_u, Lower
Lower_v)
        , (Lower
Lower_v, Lower
Lower_w)
        , (Lower
Lower_w, Lower
Lower_x)
        , (Lower
Lower_x, Lower
Lower_y)
        , (Lower
Lower_y, Lower
Lower_z)
        , (Lower
Lower_z, Lower
Lower_a)
        ]
  in  forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` NonEmpty (Lower, Lower)
r)
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` ((\(Lower
m, Lower
n) -> (Lower
n, Lower
m)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (Lower, Lower)
r))

rotate1_upper ::
  Iso'
    Upper
    Upper
rotate1_upper :: Iso' Upper Upper
rotate1_upper =
  let r :: NonEmpty (Upper, Upper)
r =
        (Upper
Upper_A, Upper
Upper_B) forall a. a -> [a] -> NonEmpty a
:|
        [
          (Upper
Upper_B, Upper
Upper_C)
        , (Upper
Upper_C, Upper
Upper_D)
        , (Upper
Upper_D, Upper
Upper_E)
        , (Upper
Upper_E, Upper
Upper_F)
        , (Upper
Upper_F, Upper
Upper_G)
        , (Upper
Upper_G, Upper
Upper_H)
        , (Upper
Upper_H, Upper
Upper_I)
        , (Upper
Upper_I, Upper
Upper_J)
        , (Upper
Upper_J, Upper
Upper_K)
        , (Upper
Upper_K, Upper
Upper_L)
        , (Upper
Upper_L, Upper
Upper_M)
        , (Upper
Upper_M, Upper
Upper_N)
        , (Upper
Upper_N, Upper
Upper_O)
        , (Upper
Upper_O, Upper
Upper_P)
        , (Upper
Upper_P, Upper
Upper_Q)
        , (Upper
Upper_Q, Upper
Upper_R)
        , (Upper
Upper_R, Upper
Upper_S)
        , (Upper
Upper_S, Upper
Upper_T)
        , (Upper
Upper_T, Upper
Upper_U)
        , (Upper
Upper_U, Upper
Upper_V)
        , (Upper
Upper_V, Upper
Upper_W)
        , (Upper
Upper_W, Upper
Upper_X)
        , (Upper
Upper_X, Upper
Upper_Y)
        , (Upper
Upper_Y, Upper
Upper_Z)
        , (Upper
Upper_Z, Upper
Upper_A)
        ]
  in  forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` NonEmpty (Upper, Upper)
r)
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` ((\(Upper
m, Upper
n) -> (Upper
n, Upper
m)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (Upper, Upper)
r))

rotate1_alpha ::
  Iso'
    Alpha
    Alpha
rotate1_alpha :: Iso' Alpha Alpha
rotate1_alpha =
  forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
    (\Alpha
a ->  case Alpha
a of
              AlphaLower Lower
l ->
                Lower -> Alpha
AlphaLower
                  (Lower
l forall s a. s -> Getting a s a -> a
^. Iso' Lower Lower
rotate1_lower)
              AlphaUpper Upper
u ->
                Upper -> Alpha
AlphaUpper
                  (Upper
u forall s a. s -> Getting a s a -> a
^. Iso' Upper Upper
rotate1_upper))
    (\Alpha
a ->  case Alpha
a of
              AlphaLower Lower
l ->
                Lower -> Alpha
AlphaLower
                  (Iso' Lower Lower
rotate1_lower forall t b. AReview t b -> b -> t
# Lower
l)
              AlphaUpper Upper
u ->
                Upper -> Alpha
AlphaUpper
                  (Iso' Upper Upper
rotate1_upper forall t b. AReview t b -> b -> t
# Upper
u))

mirror_lower ::
  Iso'
    Lower
    Lower
mirror_lower :: Iso' Lower Lower
mirror_lower =
  let r :: NonEmpty (Lower, Lower)
r =
        (Lower
Lower_a, Lower
Lower_z) forall a. a -> [a] -> NonEmpty a
:|
        [
          (Lower
Lower_b, Lower
Lower_y)
        , (Lower
Lower_c, Lower
Lower_x)
        , (Lower
Lower_d, Lower
Lower_w)
        , (Lower
Lower_e, Lower
Lower_v)
        , (Lower
Lower_f, Lower
Lower_u)
        , (Lower
Lower_g, Lower
Lower_t)
        , (Lower
Lower_h, Lower
Lower_s)
        , (Lower
Lower_i, Lower
Lower_r)
        , (Lower
Lower_j, Lower
Lower_q)
        , (Lower
Lower_k, Lower
Lower_p)
        , (Lower
Lower_l, Lower
Lower_o)
        , (Lower
Lower_m, Lower
Lower_n)
        , (Lower
Lower_n, Lower
Lower_m)
        , (Lower
Lower_o, Lower
Lower_l)
        , (Lower
Lower_p, Lower
Lower_k)
        , (Lower
Lower_q, Lower
Lower_j)
        , (Lower
Lower_r, Lower
Lower_i)
        , (Lower
Lower_s, Lower
Lower_h)
        , (Lower
Lower_t, Lower
Lower_g)
        , (Lower
Lower_u, Lower
Lower_f)
        , (Lower
Lower_v, Lower
Lower_e)
        , (Lower
Lower_w, Lower
Lower_d)
        , (Lower
Lower_x, Lower
Lower_c)
        , (Lower
Lower_y, Lower
Lower_b)
        , (Lower
Lower_z, Lower
Lower_a)
        ]
  in  forall a. (a -> a) -> Iso' a a
involuted
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` NonEmpty (Lower, Lower)
r)

mirror_upper ::
  Iso'
    Upper
    Upper
mirror_upper :: Iso' Upper Upper
mirror_upper =
  let r :: NonEmpty (Upper, Upper)
r =
        (Upper
Upper_A, Upper
Upper_Z) forall a. a -> [a] -> NonEmpty a
:|
        [
          (Upper
Upper_B, Upper
Upper_Y)
        , (Upper
Upper_C, Upper
Upper_X)
        , (Upper
Upper_D, Upper
Upper_W)
        , (Upper
Upper_E, Upper
Upper_V)
        , (Upper
Upper_F, Upper
Upper_U)
        , (Upper
Upper_G, Upper
Upper_T)
        , (Upper
Upper_H, Upper
Upper_S)
        , (Upper
Upper_I, Upper
Upper_R)
        , (Upper
Upper_J, Upper
Upper_Q)
        , (Upper
Upper_K, Upper
Upper_P)
        , (Upper
Upper_L, Upper
Upper_O)
        , (Upper
Upper_M, Upper
Upper_N)
        , (Upper
Upper_N, Upper
Upper_M)
        , (Upper
Upper_O, Upper
Upper_L)
        , (Upper
Upper_P, Upper
Upper_K)
        , (Upper
Upper_Q, Upper
Upper_J)
        , (Upper
Upper_R, Upper
Upper_I)
        , (Upper
Upper_S, Upper
Upper_H)
        , (Upper
Upper_T, Upper
Upper_G)
        , (Upper
Upper_U, Upper
Upper_F)
        , (Upper
Upper_V, Upper
Upper_E)
        , (Upper
Upper_W, Upper
Upper_D)
        , (Upper
Upper_X, Upper
Upper_C)
        , (Upper
Upper_Y, Upper
Upper_B)
        , (Upper
Upper_Z, Upper
Upper_A)
        ]
  in  forall a. (a -> a) -> Iso' a a
involuted
        (forall a b. Eq a => a -> NonEmpty (a, b) -> b
`lookup1` NonEmpty (Upper, Upper)
r)

mirror_alpha ::
  Iso'
    Alpha
    Alpha
mirror_alpha :: Iso' Alpha Alpha
mirror_alpha =
  forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
    (\Alpha
a ->  case Alpha
a of
              AlphaLower Lower
l ->
                Lower -> Alpha
AlphaLower
                  (Lower
l forall s a. s -> Getting a s a -> a
^. Iso' Lower Lower
mirror_lower)
              AlphaUpper Upper
u ->
                Upper -> Alpha
AlphaUpper
                  (Upper
u forall s a. s -> Getting a s a -> a
^. Iso' Upper Upper
mirror_upper))
    (\Alpha
a ->  case Alpha
a of
              AlphaLower Lower
l ->
                Lower -> Alpha
AlphaLower
                  (Iso' Lower Lower
mirror_lower forall t b. AReview t b -> b -> t
# Lower
l)
              AlphaUpper Upper
u ->
                Upper -> Alpha
AlphaUpper
                  (Iso' Upper Upper
mirror_upper forall t b. AReview t b -> b -> t
# Upper
u))