-- Parser generated by Pappy - do not edit
module LexerPappy where

import Pos
import Parse


import System.Environment
import Data.Maybe

ml = maybeToList




type TailTerms = ([Term], Maybe Clause, [Free])
type Term = Sumti

type Text = Sentence
type Paragraphs = Sentence
type Paragraph = Sentence
type Fragment = Sentence
type Statement = Sentence

data Sentence
	= SelbriTailTerms Selbri [Term] (Maybe Clause) [Free]
	| GihekBO Sentence Gihek (Maybe Tag) Clause [Free] Sentence [Term]
		(Maybe Clause) [Free]
	| GihekSentence Sentence
		[(Gihek, [Free], Sentence, [Term], Maybe Clause, [Free])]
	| GihekKE Sentence Gihek (Maybe Tag) Clause [Free] Sentence (Maybe Clause)
		[Free] [Term] (Maybe Clause) [Free]
	| TermsBridiTail [Term] (Maybe Clause) [Free] Sentence
	| TUhE (Maybe Tag) Clause [Free] Text (Maybe Clause) [Free]
	| IBO Statement Clause (Maybe JoikJek) (Maybe Tag) Clause [Free] Statement
	| IJoikJek Statement [(Clause, JoikJek, [Free], Maybe Statement)]
	| Prenex [Term] Clause [Free] Statement
	| FPrenex [Term] Clause [Free]
	| StatementI Statement [(Clause, [Free], Maybe Statement)]
	| NIhO Paragraph [Clause] [Free] Paragraphs
	| IText_1 Clause (Maybe JoikJek) (Maybe (Maybe Tag, Clause)) [Free]
		(Maybe Text)
	| HeadNIhO [Clause] [Free] (Maybe Paragraphs)
	| TopText [Clause] (Either [Clause] (Maybe [([String], String)])) [Free]
		(Maybe (JoikJek, [Free])) (Maybe Text) (Maybe Pre)
	deriving Show

data Sumti
	= LOhU [String] String [String] Pre Indicators [Free]
	| LerfuString LerfuString (Maybe Clause) [Free]
	| LU Clause Text (Maybe Clause) [Free]
	| LAhE_NAhE Clause (Maybe Clause) [Free] (Maybe RelativeClauses)
		Sumti (Maybe Clause) [Free]
	| KOhA Clause [Free]
	| LALE Clause [Free] SumtiTail (Maybe Clause) [Free]
	| LA Clause [Free] (Maybe RelativeClauses) [Clause] [Free]
	| LI Clause [Free] Mex (Maybe Clause) [Free]
	| OuterQuantifier (Maybe Quantifier) Sumti (Maybe RelativeClauses)
	| SQuantifierSelbri Quantifier Selbri (Maybe Clause) [Free]
		(Maybe RelativeClauses)
	| GekSumti Gek Sumti Gik Sumti
	| JoikEkBOSumti Sumti JoikEk [Free] (Maybe Tag) Clause [Free] Sumti
	| JoikEkSumti Sumti [(JoikEk, [Free], Sumti)]
	| JoikEkKESumti Sumti JoikEk [Free] (Maybe Tag) Clause [Free] Sumti
		(Maybe Clause) [Free]
	| VUhO Sumti Clause [Free] RelativeClauses
	deriving Show

data SumtiTail
	= SumtiSumtiTail Sumti (Maybe RelativeClauses) SumtiTail
	| RelativeClausesSumtiTail RelativeClauses SumtiTail
	| SelbriRelativeClauses Selbri (Maybe RelativeClauses)
	| STQuantifierSelbri Quantifier Selbri (Maybe RelativeClauses)
	| QuantifierSumti Quantifier Sumti
	deriving Show

data Selbri
	= Brivla Clause [Free]
	| Linkargs Selbri Linkargs
	| CEI Selbri [(Clause, [Free], Selbri)]
	| BO Selbri Clause [Free] Selbri
	| GuhekGik (Maybe Clause) [Free] Guhek Selbri Gik Selbri
	| JekJoikBO Selbri JoikJek (Maybe Tag) Clause [Free] Selbri
	| JoikJek Selbri [JoikJekSelbri5]
	| Tanru [Selbri]
	| CO Selbri Clause [Free] Selbri
	| NA Clause [Free] Selbri
	| Tag Tag Selbri
	deriving Show

type RelativeClauses = String

type JoikJekSelbri5 = Either (JoikJek, [Free], Selbri)
	(Joik, (Maybe Tag), Clause, [Free], Selbri, Maybe Clause, [Free])

type Linkargs = String

type Quantifier = String
type Mex = String
type LerfuString = String

data Free
	= VocativeSumti [Clause] (Maybe Sumti) (Maybe Clause)
	deriving Show

type Clause = ([String], String, Indicators)
type Pre = ([String], String)
type Indicators = [[([String], String)]]

type Ek = JoikJek
type Jek = JoikJek
type Joik = JoikJek
type JoikEk = JoikJek
type Gihek = JoikJek
data JoikJek
	= JOI (Maybe Clause) (Clause) (Maybe Clause)
	| Jek (Maybe Clause) (Maybe Clause) Clause (Maybe Clause)
	| Ek (Maybe Clause) (Maybe Clause) Clause (Maybe Clause)
	| Gihek (Maybe Clause) (Maybe Clause) Clause (Maybe Clause)
	deriving Show
data Gek
	= GA (Maybe Clause) Clause (Maybe Clause) [Free]
	| JoikGI Joik Clause [Free]
	| STagGik Tag Gik
	deriving Show
-- type Guhek = ([Clause], [Free])
-- type Gik = ([Clause], [Free])
type Guhek = (Maybe Clause, Clause, Maybe Clause, [Free])
type Gik = (Clause, Maybe Clause, [Free])

type Tag = String

{-
main = do
	[str] <- getArgs
	case lexerPappytest_words $ lexerPappyParse "test_words" str of
		Parsed v _ _ -> print v
		NoParse e -> error (show e)
-}

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
uncurry3 f (x, y, z) = f x y z

isSimpleText :: [Clause] -> (Either [Clause] (Maybe [([String], String)]), [Free]) -> 
	Maybe (JoikJek, [Free]) -> Maybe Text -> Maybe Pre -> Bool
isSimpleText n tp2 jj t f =
	null n && isNothing (fromRight $ fst tp2) && null (snd tp2) &&
	isNothing jj && isJust t && isNothing f

fromRight :: Either a b -> b
fromRight = either (const $ error "not Right") id


data LexerPappyDerivs = LexerPappyDerivs {
	lexerPappySub0 :: LexerPappyDerivs0,
	lexerPappySub1 :: LexerPappyDerivs1,
	lexerPappySub2 :: LexerPappyDerivs2,
	lexerPappySub3 :: LexerPappyDerivs3,
	lexerPappyChar :: Result LexerPappyDerivs Char,
	lexerPappyPos :: Pos
}

instance Derivs LexerPappyDerivs where
	dvChar d = lexerPappyChar d
	dvPos d = lexerPappyPos d

data LexerPappyDerivs0 = LexerPappyDerivs0 {
	lexerPappySubStarRule0 :: Result LexerPappyDerivs ([ (String, String) ]),
	lexerPappySubPlusRule0 :: Result LexerPappyDerivs ([String]),
	lexerPappySubcmene :: Result LexerPappyDerivs (String),
	lexerPappySubStarRule1 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubcmavo :: Result LexerPappyDerivs (String),
	lexerPappySubStarRule3 :: Result LexerPappyDerivs ([String]),
	lexerPappySubStarRule4 :: Result LexerPappyDerivs ([String]),
	lexerPappySubbrivla_core :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_extended_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubextended_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubStarRule6 :: Result LexerPappyDerivs ([String]),
	lexerPappySubStarRule7 :: Result LexerPappyDerivs ([String]),
	lexerPappySubbrivla_head :: Result LexerPappyDerivs (String),
	lexerPappySubStarRule8 :: Result LexerPappyDerivs ([String]),
	lexerPappySubrafsi_string :: Result LexerPappyDerivs (String),
	lexerPappySubCVV_final_rafsi :: Result LexerPappyDerivs (String)}

data LexerPappyDerivs1 = LexerPappyDerivs1 {
	lexerPappySubshort_final_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_y_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_y_less_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_long_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySuby_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySuby_less_rafsi :: Result LexerPappyDerivs (String),
	lexerPappySubr_hyphen :: Result LexerPappyDerivs (Char),
	lexerPappySubfinal_syllable :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_syllable :: Result LexerPappyDerivs (String),
	lexerPappySubstressed_vowel :: Result LexerPappyDerivs (Char),
	lexerPappySubunstressed_syllable :: Result LexerPappyDerivs (String),
	lexerPappySubStarRule9 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubconsonantal_syllable :: Result LexerPappyDerivs (String),
	lexerPappySubcoda :: Result LexerPappyDerivs (String),
	lexerPappySubonset :: Result LexerPappyDerivs (String),
	lexerPappySubglide :: Result LexerPappyDerivs (Char)}

data LexerPappyDerivs2 = LexerPappyDerivs2 {
	lexerPappySubdiphthong :: Result LexerPappyDerivs (String),
	lexerPappySubvowel :: Result LexerPappyDerivs (Char),
	lexerPappySubPlusRule2 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubinitial_pair :: Result LexerPappyDerivs (String),
	lexerPappySubinitial :: Result LexerPappyDerivs (String),
	lexerPappySubl :: Result LexerPappyDerivs (Char),
	lexerPappySubm :: Result LexerPappyDerivs (Char),
	lexerPappySubn :: Result LexerPappyDerivs (Char),
	lexerPappySubr :: Result LexerPappyDerivs (Char),
	lexerPappySubb :: Result LexerPappyDerivs (Char),
	lexerPappySubd :: Result LexerPappyDerivs (Char),
	lexerPappySubg :: Result LexerPappyDerivs (Char),
	lexerPappySubv :: Result LexerPappyDerivs (Char),
	lexerPappySubj :: Result LexerPappyDerivs (Char),
	lexerPappySubz :: Result LexerPappyDerivs (Char),
	lexerPappySubs :: Result LexerPappyDerivs (Char)}

data LexerPappyDerivs3 = LexerPappyDerivs3 {
	lexerPappySubc :: Result LexerPappyDerivs (Char),
	lexerPappySubx :: Result LexerPappyDerivs (Char),
	lexerPappySubk :: Result LexerPappyDerivs (Char),
	lexerPappySubf :: Result LexerPappyDerivs (Char),
	lexerPappySubp :: Result LexerPappyDerivs (Char),
	lexerPappySubt :: Result LexerPappyDerivs (Char),
	lexerPappySubdigit :: Result LexerPappyDerivs (Char),
	lexerPappySubPlusRule3 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubspaces :: Result LexerPappyDerivs ( String ),
	lexerPappySubPlusRule4 :: Result LexerPappyDerivs ([ String ]),
	lexerPappySubStarRule37 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubStarRule38 :: Result LexerPappyDerivs ([ Char ]),
	lexerPappySubybu :: Result LexerPappyDerivs (String),
	lexerPappySubPlusRule5 :: Result LexerPappyDerivs ([Char]),
	lexerPappySubdummyTail :: Result LexerPappyDerivs ((() -> ())),
	lexerPappySubdummy :: Result LexerPappyDerivs (())}

lexerPappyStarRule0 = lexerPappySubStarRule0 . lexerPappySub0
lexerPappyPlusRule0 = lexerPappySubPlusRule0 . lexerPappySub0
lexerPappycmene = lexerPappySubcmene . lexerPappySub0
lexerPappyStarRule1 = lexerPappySubStarRule1 . lexerPappySub0
lexerPappycmavo = lexerPappySubcmavo . lexerPappySub0
lexerPappyStarRule3 = lexerPappySubStarRule3 . lexerPappySub0
lexerPappyStarRule4 = lexerPappySubStarRule4 . lexerPappySub0
lexerPappybrivla_core = lexerPappySubbrivla_core . lexerPappySub0
lexerPappystressed_extended_rafsi = lexerPappySubstressed_extended_rafsi . lexerPappySub0
lexerPappyextended_rafsi = lexerPappySubextended_rafsi . lexerPappySub0
lexerPappyStarRule6 = lexerPappySubStarRule6 . lexerPappySub0
lexerPappyStarRule7 = lexerPappySubStarRule7 . lexerPappySub0
lexerPappybrivla_head = lexerPappySubbrivla_head . lexerPappySub0
lexerPappyStarRule8 = lexerPappySubStarRule8 . lexerPappySub0
lexerPappyrafsi_string = lexerPappySubrafsi_string . lexerPappySub0
lexerPappyCVV_final_rafsi = lexerPappySubCVV_final_rafsi . lexerPappySub0
lexerPappyshort_final_rafsi = lexerPappySubshort_final_rafsi . lexerPappySub1
lexerPappystressed_y_rafsi = lexerPappySubstressed_y_rafsi . lexerPappySub1
lexerPappystressed_y_less_rafsi = lexerPappySubstressed_y_less_rafsi . lexerPappySub1
lexerPappystressed_long_rafsi = lexerPappySubstressed_long_rafsi . lexerPappySub1
lexerPappyy_rafsi = lexerPappySuby_rafsi . lexerPappySub1
lexerPappyy_less_rafsi = lexerPappySuby_less_rafsi . lexerPappySub1
lexerPappyr_hyphen = lexerPappySubr_hyphen . lexerPappySub1
lexerPappyfinal_syllable = lexerPappySubfinal_syllable . lexerPappySub1
lexerPappystressed_syllable = lexerPappySubstressed_syllable . lexerPappySub1
lexerPappystressed_vowel = lexerPappySubstressed_vowel . lexerPappySub1
lexerPappyunstressed_syllable = lexerPappySubunstressed_syllable . lexerPappySub1
lexerPappyStarRule9 = lexerPappySubStarRule9 . lexerPappySub1
lexerPappyconsonantal_syllable = lexerPappySubconsonantal_syllable . lexerPappySub1
lexerPappycoda = lexerPappySubcoda . lexerPappySub1
lexerPappyonset = lexerPappySubonset . lexerPappySub1
lexerPappyglide = lexerPappySubglide . lexerPappySub1
lexerPappydiphthong = lexerPappySubdiphthong . lexerPappySub2
lexerPappyvowel = lexerPappySubvowel . lexerPappySub2
lexerPappyPlusRule2 = lexerPappySubPlusRule2 . lexerPappySub2
lexerPappyinitial_pair = lexerPappySubinitial_pair . lexerPappySub2
lexerPappyinitial = lexerPappySubinitial . lexerPappySub2
lexerPappyl = lexerPappySubl . lexerPappySub2
lexerPappym = lexerPappySubm . lexerPappySub2
lexerPappyn = lexerPappySubn . lexerPappySub2
lexerPappyr = lexerPappySubr . lexerPappySub2
lexerPappyb = lexerPappySubb . lexerPappySub2
lexerPappyd = lexerPappySubd . lexerPappySub2
lexerPappyg = lexerPappySubg . lexerPappySub2
lexerPappyv = lexerPappySubv . lexerPappySub2
lexerPappyj = lexerPappySubj . lexerPappySub2
lexerPappyz = lexerPappySubz . lexerPappySub2
lexerPappys = lexerPappySubs . lexerPappySub2
lexerPappyc = lexerPappySubc . lexerPappySub3
lexerPappyx = lexerPappySubx . lexerPappySub3
lexerPappyk = lexerPappySubk . lexerPappySub3
lexerPappyf = lexerPappySubf . lexerPappySub3
lexerPappyp = lexerPappySubp . lexerPappySub3
lexerPappyt = lexerPappySubt . lexerPappySub3
lexerPappydigit = lexerPappySubdigit . lexerPappySub3
lexerPappyPlusRule3 = lexerPappySubPlusRule3 . lexerPappySub3
lexerPappyspaces = lexerPappySubspaces . lexerPappySub3
lexerPappyPlusRule4 = lexerPappySubPlusRule4 . lexerPappySub3
lexerPappyStarRule37 = lexerPappySubStarRule37 . lexerPappySub3
lexerPappyStarRule38 = lexerPappySubStarRule38 . lexerPappySub3
lexerPappyybu = lexerPappySubybu . lexerPappySub3
lexerPappyPlusRule5 = lexerPappySubPlusRule5 . lexerPappySub3
lexerPappydummyTail = lexerPappySubdummyTail . lexerPappySub3
lexerPappydummy = lexerPappySubdummy . lexerPappySub3

lexerPappyParse :: String -> String -> LexerPappyDerivs
lexerPappyParse name text = lexerPappyDerivs (Pos name 1 1) text

lexerPappyDerivs :: Pos -> String -> LexerPappyDerivs
lexerPappyDerivs pos text = dvs where
  dvs = LexerPappyDerivs
    (lexerPappyDerivs0 dvs)
    (lexerPappyDerivs1 dvs)
    (lexerPappyDerivs2 dvs)
    (lexerPappyDerivs3 dvs)
    chr pos
  chr = case text of
    [] -> NoParse (eofError dvs)
    (c:cs) -> Parsed c (lexerPappyDerivs (nextPos pos c) cs) (nullError dvs)

lexerPappyDerivs0 dvs = LexerPappyDerivs0
	(lexerPappyParseStarRule0 dvs)
	(lexerPappyParsePlusRule0 dvs)
	(lexerPappyParsecmene dvs)
	(lexerPappyParseStarRule1 dvs)
	(lexerPappyParsecmavo dvs)
	(lexerPappyParseStarRule3 dvs)
	(lexerPappyParseStarRule4 dvs)
	(lexerPappyParsebrivla_core dvs)
	(lexerPappyParsestressed_extended_rafsi dvs)
	(lexerPappyParseextended_rafsi dvs)
	(lexerPappyParseStarRule6 dvs)
	(lexerPappyParseStarRule7 dvs)
	(lexerPappyParsebrivla_head dvs)
	(lexerPappyParseStarRule8 dvs)
	(lexerPappyParserafsi_string dvs)
	(lexerPappyParseCVV_final_rafsi dvs)

lexerPappyDerivs1 dvs = LexerPappyDerivs1
	(lexerPappyParseshort_final_rafsi dvs)
	(lexerPappyParsestressed_y_rafsi dvs)
	(lexerPappyParsestressed_y_less_rafsi dvs)
	(lexerPappyParsestressed_long_rafsi dvs)
	(lexerPappyParsey_rafsi dvs)
	(lexerPappyParsey_less_rafsi dvs)
	(lexerPappyParser_hyphen dvs)
	(lexerPappyParsefinal_syllable dvs)
	(lexerPappyParsestressed_syllable dvs)
	(lexerPappyParsestressed_vowel dvs)
	(lexerPappyParseunstressed_syllable dvs)
	(lexerPappyParseStarRule9 dvs)
	(lexerPappyParseconsonantal_syllable dvs)
	(lexerPappyParsecoda dvs)
	(lexerPappyParseonset dvs)
	(lexerPappyParseglide dvs)

lexerPappyDerivs2 dvs = LexerPappyDerivs2
	(lexerPappyParsediphthong dvs)
	(lexerPappyParsevowel dvs)
	(lexerPappyParsePlusRule2 dvs)
	(lexerPappyParseinitial_pair dvs)
	(lexerPappyParseinitial dvs)
	(lexerPappyParsel dvs)
	(lexerPappyParsem dvs)
	(lexerPappyParsen dvs)
	(lexerPappyParser dvs)
	(lexerPappyParseb dvs)
	(lexerPappyParsed dvs)
	(lexerPappyParseg dvs)
	(lexerPappyParsev dvs)
	(lexerPappyParsej dvs)
	(lexerPappyParsez dvs)
	(lexerPappyParses dvs)

lexerPappyDerivs3 dvs = LexerPappyDerivs3
	(lexerPappyParsec dvs)
	(lexerPappyParsex dvs)
	(lexerPappyParsek dvs)
	(lexerPappyParsef dvs)
	(lexerPappyParsep dvs)
	(lexerPappyParset dvs)
	(lexerPappyParsedigit dvs)
	(lexerPappyParsePlusRule3 dvs)
	(lexerPappyParsespaces dvs)
	(lexerPappyParsePlusRule4 dvs)
	(lexerPappyParseStarRule37 dvs)
	(lexerPappyParseStarRule38 dvs)
	(lexerPappyParseybu dvs)
	(lexerPappyParsePlusRule5 dvs)
	(lexerPappyParsedummyTail dvs)
	(lexerPappyParsedummy dvs)

lexerPappytest_words :: LexerPappyDerivs -> Result LexerPappyDerivs ( (String, [(String, String)]) )
lexerPappytest_words d =
  case pappyResult1 of
    Parsed w d1 e1 ->
      case lexerPappyanyChar d1 of
        NoParse e3 ->
          Parsed ( w ) d1 (max e3 e1)
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed p d3 e3 ->
          case lexerPappyStarRule0 d3 of
            Parsed ws d5 e5 ->
              Parsed ( maybe ("", ws) (flip (,) ws) p ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3
      where
        pappyResult3 =
          case lexerPappyspaces d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5

lexerPappyParseStarRule0 :: LexerPappyDerivs -> Result LexerPappyDerivs ([ (String, String) ])
lexerPappyParseStarRule0 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyStarRule0 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed w d5 e5 ->
              case pappyResult7 of
                Parsed ps d7 e7 ->
                  Parsed ( maybe (w, "") ((,) w) ps ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  case lexerPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case lexerPappylojban_word d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case lexerPappylojban_word d of
                    NoParse e9 ->
                      case lexerPappyPlusRule3 d of
                        Parsed ns d11 e11 ->
                          Parsed ( ns ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_3 (maximum [e11,e9,e7])
                    Parsed _ _ e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappylojban_word :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappylojban_word d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappycmene d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappycmavo d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappycmavo d of
        NoParse e3 ->
          case lexerPappyStarRule4 d of
            Parsed rs d5 e5 ->
              case lexerPappybrivla_core d5 of
                Parsed b d7 e7 ->
                  Parsed ( concat rs ++ b ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        Parsed _ _ e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappyParsePlusRule0 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParsePlusRule0 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyPlusRule0 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyany_syllable d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappydigit d of
                Parsed d d7 e7 ->
                  Parsed ( [d] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyany_syllable d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappydigit d of
                Parsed d d7 e7 ->
                  Parsed ( [d] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsecmene :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsecmene d =
  case lexerPappyh d of
    NoParse e1 ->
      case pappyResult3 of
        Parsed _ _ e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case lexerPappyPlusRule0 d5 of
                Parsed r d7 e7 ->
                  case lexerPappypause d7 of
                    Parsed _ _ e9 ->
                      Parsed ( fromMaybe "" c ++ concat r ) d7 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case lexerPappycoda d of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case lexerPappyStarRule1 d of
            Parsed s d5 e5 ->
              case lexerPappyconsonant d5 of
                Parsed c d7 e7 ->
                  case lexerPappypause d7 of
                    Parsed _ _ e9 ->
                      Parsed ( s ++ [c] ) d7 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    Parsed _ _ e1 -> NoParse e1

lexerPappyParseStarRule1 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParseStarRule1 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyStarRule1 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappynon_space d of
            Parsed n d5 e5 ->
              case lexerPappynon_space d5 of
                Parsed _ _ e7 ->
                  Parsed ( n ) d5 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsecmavo :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsecmavo d =
  case lexerPappycmene d of
    NoParse e1 ->
      case pappyResult3 of
        NoParse e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case lexerPappypost_word d5 of
                Parsed _ _ e7 ->
                  Parsed ( c ) d5 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case lexerPappyh d of
                    NoParse e9 ->
                      case lexerPappycluster d of
                        NoParse e11 ->
                          case lexerPappyonset d of
                            Parsed o d13 e13 ->
                              case lexerPappyStarRule3 d13 of
                                Parsed nh d15 e15 ->
                                  case pappyResult17 of
                                    Parsed nn d17 e17 ->
                                      Parsed ( o ++ concat nh ++ nn ) d17 (maximum [e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> pappyAlt7_2 (maximum [e17,e15,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      pappyAlt19_1 (ParseError (lexerPappyPos d15) []) where
                                        pappyAlt19_1 e19 =
                                          case lexerPappystressed d15 of
                                            NoParse e21 ->
                                              case lexerPappynucleus d15 of
                                                Parsed n d23 e23 ->
                                                  Parsed ( n ) d23 (maximum [e23,e21,e19])
                                                NoParse e23 -> pappyAlt19_2 (maximum [e23,e21,e19])
                                            Parsed _ _ e21 -> pappyAlt19_2 (max e21 e19)
                                        pappyAlt19_2 e19 =
                                          case lexerPappynucleus d15 of
                                            Parsed n d21 e21 ->
                                              case lexerPappycluster d21 of
                                                NoParse e23 ->
                                                  Parsed ( n ) d21 (maximum [e23,e21,e19])
                                                Parsed _ _ e23 -> pappyAlt19_3 (maximum [e23,e21,e19])
                                            NoParse e21 -> pappyAlt19_3 (max e21 e19)
                                        pappyAlt19_3 e19 = NoParse e19
                                NoParse e15 -> pappyAlt7_2 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_2 (maximum [e13,e11,e9,e7])
                        Parsed _ _ e11 -> pappyAlt7_2 (maximum [e11,e9,e7])
                    Parsed _ _ e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case lexerPappyPlusRule5 d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 =
                  case lexerPappydigit d of
                    Parsed d d9 e9 ->
                      Parsed ( [d] ) d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_4 (max e9 e7)
                pappyAlt7_4 e7 = NoParse e7
        Parsed _ _ e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyCVC_rafsi d of
                Parsed r d7 e7 ->
                  case lexerPappyy d7 of
                    Parsed y d9 e9 ->
                      case pappyResult11 of
                        Parsed h d11 e11 ->
                          case lexerPappyStarRule4 d11 of
                            Parsed rs d13 e13 ->
                              case lexerPappybrivla_core d13 of
                                Parsed b d15 e15 ->
                                  Parsed ( r ++ [y] ++ ml h ++ concat rs ++ b ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> pappyAlt5_2 (maximum [e15,e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case lexerPappyh d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappystressed_CVC_rafsi d of
                Parsed r d7 e7 ->
                  case lexerPappyy d7 of
                    Parsed y d9 e9 ->
                      case lexerPappyshort_final_rafsi d9 of
                        Parsed f d11 e11 ->
                          Parsed ( r ++ [y] ++ f ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    Parsed _ _ e1 -> NoParse e1

lexerPappyParseStarRule3 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParseStarRule3 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyStarRule3 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappynucleus d of
            Parsed n d5 e5 ->
              case lexerPappyh d5 of
                Parsed h d7 e7 ->
                  Parsed ( n ++ [h] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseStarRule4 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParseStarRule4 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyStarRule4 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyextended_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyy_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case lexerPappyany_extended_rafsi d of
                NoParse e7 ->
                  case lexerPappyy_less_rafsi d of
                    Parsed r d9 e9 ->
                      Parsed ( r ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                Parsed _ _ e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsebrivla_core :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsebrivla_core d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyfuhivla d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappygismu d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyCVV_final_rafsi d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed i d3 e3 ->
          case lexerPappyshort_final_rafsi d3 of
            Parsed f d5 e5 ->
              Parsed ( i ++ f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappystressed_extended_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappystressed_y_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case lexerPappystressed_y_less_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    pappyAlt1_5 e1 = NoParse e1

lexerPappyany_extended_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyany_extended_rafsi d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyfuhivla d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyextended_rafsi d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappystressed_extended_rafsi d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappyfuhivla :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyfuhivla d =
  case lexerPappyfuhivla_head d of
    Parsed f d1 e1 ->
      case lexerPappystressed_syllable d1 of
        Parsed s d3 e3 ->
          case lexerPappyStarRule6 d3 of
            Parsed ss d5 e5 ->
              case lexerPappyfinal_syllable d5 of
                Parsed t d7 e7 ->
                  Parsed ( f ++ s ++ concat ss ++ t ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsestressed_extended_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsestressed_extended_rafsi d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyunstressed_syllable d of
        Parsed _ _ e3 ->
          case lexerPappybrivla_head d of
            Parsed b d5 e5 ->
              case lexerPappystressed_syllable d5 of
                Parsed s d7 e7 ->
                  case lexerPappyh d7 of
                    Parsed h d9 e9 ->
                      case lexerPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( b ++ s ++ [h, y] ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_2 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyfuhivla_head d of
        Parsed f d3 e3 ->
          case lexerPappystressed_syllable d3 of
            Parsed s d5 e5 ->
              case lexerPappyconsonant d5 of
                Parsed _ _ e7 ->
                  case lexerPappyonset d5 of
                    Parsed o d9 e9 ->
                      case lexerPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( f ++ s ++ o ++ [y] ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_3 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseextended_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseextended_rafsi d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed _ _ e3 ->
          case lexerPappybrivla_head d of
            Parsed b d5 e5 ->
              case lexerPappyh d5 of
                Parsed h d7 e7 ->
                  case lexerPappyy d7 of
                    Parsed y d9 e9 ->
                      case pappyResult11 of
                        Parsed i d11 e11 ->
                          Parsed ( b ++ [h, y] ++ ml i ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_2 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case lexerPappyh d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappysyllable d of
            Parsed _ d5 e5 ->
              case lexerPappyStarRule6 d5 of
                Parsed _ d7 e7 ->
                  case lexerPappysyllable d7 of
                    Parsed _ d9 e9 ->
                      Parsed ( () ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      case lexerPappyunstressed_syllable d of
        Parsed _ _ e3 ->
          case lexerPappyfuhivla_head d of
            Parsed f d5 e5 ->
              case lexerPappyconsonant d5 of
                Parsed _ _ e7 ->
                  case lexerPappyonset d5 of
                    Parsed o d9 e9 ->
                      case lexerPappyy d9 of
                        Parsed y d11 e11 ->
                          case pappyResult13 of
                            Parsed h d13 e13 ->
                              Parsed ( f ++ o ++ [y] ++ ml h ) d13 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_3 (maximum [e13,e11,e9,e7,e5,e3,e1])
                          where
                            pappyResult13 =
                              case lexerPappyh d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt1_3 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseStarRule6 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParseStarRule6 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyconsonantal_syllable d of
        Parsed v d3 e3 ->
          case lexerPappyStarRule6 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyfuhivla_head :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyfuhivla_head d =
  case lexerPappyrafsi_string d of
    NoParse e1 ->
      case lexerPappybrivla_head d of
        Parsed b d3 e3 ->
          Parsed ( b ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

lexerPappyParseStarRule7 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParseStarRule7 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyunstressed_syllable d of
        Parsed v d3 e3 ->
          case lexerPappyStarRule7 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsebrivla_head :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsebrivla_head d =
  case lexerPappycmavo d of
    NoParse e1 ->
      case pappyResult3 of
        NoParse e3 ->
          case lexerPappyh d of
            NoParse e5 ->
              case lexerPappyonset d of
                Parsed _ _ e7 ->
                  case lexerPappyStarRule7 d of
                    Parsed ss d9 e9 ->
                      Parsed ( concat ss ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        Parsed _ _ e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case lexerPappyconsonant d of
            Parsed c d5 e5 ->
              case lexerPappyrafsi_string d5 of
                Parsed r d7 e7 ->
                  Parsed ( c : r ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    Parsed _ _ e1 -> NoParse e1

lexerPappyParseStarRule8 :: LexerPappyDerivs -> Result LexerPappyDerivs ([String])
lexerPappyParseStarRule8 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyy_less_rafsi d of
        Parsed v d3 e3 ->
          case lexerPappyStarRule8 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParserafsi_string :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParserafsi_string d =
  case lexerPappyStarRule8 d of
    Parsed ylrs d1 e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          Parsed ( concat ylrs ++ r ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappygismu d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyCVV_final_rafsi d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case lexerPappystressed_y_less_rafsi d1 of
                Parsed ylr d7 e7 ->
                  case lexerPappyshort_final_rafsi d7 of
                    Parsed sfr d9 e9 ->
                      Parsed ( ylr ++ sfr ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case lexerPappyy_rafsi d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case lexerPappystressed_y_rafsi d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case pappyResult7 of
                Parsed ylr d7 e7 ->
                  case lexerPappyinitial_pair d7 of
                    Parsed p d9 e9 ->
                      case lexerPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( fromMaybe "" ylr ++ p ++ [y] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_7 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_7 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_7 (max e7 e5)
              where
                pappyResult7 =
                  case lexerPappystressed_y_less_rafsi d1 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d1 e9
            pappyAlt5_7 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappygismu :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappygismu d =
  case lexerPappystressed_long_rafsi d of
    Parsed r d1 e1 ->
      case lexerPappyfinal_syllable d1 of
        Parsed _ _ e3 ->
          case lexerPappyvowel d1 of
            Parsed v d5 e5 ->
              case lexerPappypost_word d5 of
                Parsed _ _ e7 ->
                  Parsed ( r ++ [v] ) d5 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseCVV_final_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseCVV_final_rafsi d =
  case lexerPappyconsonant d of
    Parsed c d1 e1 ->
      case lexerPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          case lexerPappyh d3 of
            Parsed h d5 e5 ->
              case lexerPappyfinal_syllable d5 of
                Parsed _ _ e7 ->
                  case lexerPappyvowel d5 of
                    Parsed w d9 e9 ->
                      case lexerPappypost_word d9 of
                        Parsed _ _ e11 ->
                          Parsed ( c : v : h : w : [] ) d9 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseshort_final_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseshort_final_rafsi d =
  case lexerPappyfinal_syllable d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case lexerPappypost_word d3 of
            Parsed _ _ e5 ->
              Parsed ( r ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyconsonant d of
                Parsed c d7 e7 ->
                  case lexerPappydiphthong d7 of
                    Parsed d d9 e9 ->
                      Parsed ( c : d ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyinitial_pair d of
                Parsed p d7 e7 ->
                  case lexerPappyvowel d7 of
                    Parsed v d9 e9 ->
                      Parsed ( p ++ [v] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsestressed_y_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsestressed_y_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case lexerPappyy d1 of
        Parsed y d3 e3 ->
          Parsed ( r ++ [y] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappystressed_long_rafsi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case lexerPappystressed_CVC_rafsi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

lexerPappyParsestressed_y_less_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsestressed_y_less_rafsi d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappystressed_CVC_rafsi d of
        Parsed r d3 e3 ->
          case lexerPappyy d3 of
            NoParse e5 ->
              Parsed ( r ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappystressed_CCV_rafsi d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyconsonant d of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed vv d5 e5 ->
              case pappyResult7 of
                Parsed r d7 e7 ->
                  Parsed ( c : vv ++ ml r ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case lexerPappyr_hyphen d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case lexerPappyunstressed_vowel d3 of
                    Parsed v d9 e9 ->
                      case lexerPappyh d9 of
                        Parsed h d11 e11 ->
                          case lexerPappystressed_vowel d11 of
                            Parsed w d13 e13 ->
                              Parsed ( [v, h, w] ) d13 (maximum [e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_2 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_2 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  pappyAlt9_1 e7 where
                    pappyAlt9_1 e9 =
                      case lexerPappystressed d3 of
                        Parsed _ _ e11 ->
                          case lexerPappydiphthong d3 of
                            Parsed d d13 e13 ->
                              Parsed ( d ) d13 (maximum [e13,e11,e9])
                            NoParse e13 -> pappyAlt9_2 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case lexerPappydiphthong d3 of
                        Parsed d d11 e11 ->
                          case lexerPappystress d11 of
                            Parsed _ _ e13 ->
                              Parsed ( d ) d11 (maximum [e13,e11,e9])
                            NoParse e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = pappyAlt7_3 e9
                pappyAlt7_3 e7 = NoParse e7
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappyParsestressed_long_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsestressed_long_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case lexerPappyconsonant d1 of
        Parsed c d3 e3 ->
          Parsed ( r ++ [c] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappystressed_CCV_rafsi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case lexerPappystressed_CVC_rafsi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

lexerPappystressed_CVC_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappystressed_CVC_rafsi d =
  case lexerPappyconsonant d of
    Parsed c d1 e1 ->
      case lexerPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          case lexerPappyconsonant d3 of
            Parsed d d5 e5 ->
              Parsed ( [c, v, d] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappystressed_CCV_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappystressed_CCV_rafsi d =
  case lexerPappyinitial_pair d of
    Parsed p d1 e1 ->
      case lexerPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          Parsed ( p ++ [v] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsey_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsey_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case lexerPappyy d1 of
        Parsed y d3 e3 ->
          case pappyResult5 of
            Parsed h d5 e5 ->
              Parsed ( r ++ [y] ++ ml h ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case lexerPappyh d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case pappyResult5 of
            Parsed r d5 e5 ->
              case lexerPappyconsonant d5 of
                Parsed c d7 e7 ->
                  Parsed ( r ++ [c] ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_2 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case lexerPappyCCV_rafsi d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case lexerPappyCVC_rafsi d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
        pappyAlt3_2 e3 =
          case lexerPappyCVC_rafsi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

lexerPappyParsey_less_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsey_less_rafsi d =
  case lexerPappyy_rafsi d of
    NoParse e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case lexerPappyany_extended_rafsi d3 of
            NoParse e5 ->
              Parsed ( r ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyCVC_rafsi d of
                Parsed cvcr d7 e7 ->
                  case lexerPappyy d7 of
                    NoParse e9 ->
                      Parsed ( cvcr ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyCCV_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case lexerPappyconsonant d of
                Parsed c d7 e7 ->
                  case pappyResult9 of
                    Parsed vv d9 e9 ->
                      case pappyResult11 of
                        Parsed r d11 e11 ->
                          Parsed ( c : vv ++ ml r ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case lexerPappyr_hyphen d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (lexerPappyPos d7) []) where
                        pappyAlt11_1 e11 =
                          case lexerPappyunstressed_vowel d7 of
                            Parsed v d13 e13 ->
                              case lexerPappyh d13 of
                                Parsed h d15 e15 ->
                                  case lexerPappyunstressed_vowel d15 of
                                    Parsed w d17 e17 ->
                                      Parsed ( [v, h, w] ) d17 (maximum [e17,e15,e13,e11])
                                    NoParse e17 -> pappyAlt11_2 (maximum [e17,e15,e13,e11])
                                NoParse e15 -> pappyAlt11_2 (maximum [e15,e13,e11])
                            NoParse e13 -> pappyAlt11_2 (max e13 e11)
                        pappyAlt11_2 e11 =
                          case pappyResult13 of
                            Parsed d d13 e13 ->
                              Parsed ( d ) d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_3 (max e13 e11)
                          where
                            pappyResult13 =
                              case lexerPappystressed d7 of
                                NoParse e15 ->
                                  case lexerPappydiphthong d7 of
                                    Parsed d d17 e17 ->
                                      case lexerPappystress d17 of
                                        NoParse e19 ->
                                          Parsed ( d ) d17 (maximum [e19,e17,e15])
                                        Parsed _ _ e19 -> NoParse (maximum [e19,e17,e15])
                                    NoParse e17 -> NoParse (max e17 e15)
                                Parsed _ _ e15 -> NoParse e15
                        pappyAlt11_3 e11 = NoParse e11
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    Parsed _ _ e1 -> NoParse e1

lexerPappyCVC_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyCVC_rafsi d =
  case lexerPappyconsonant d of
    Parsed c d1 e1 ->
      case lexerPappyunstressed_vowel d1 of
        Parsed v d3 e3 ->
          case lexerPappyconsonant d3 of
            Parsed d d5 e5 ->
              Parsed ( [c, v, d] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyCCV_rafsi :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyCCV_rafsi d =
  case lexerPappyinitial_pair d of
    Parsed i d1 e1 ->
      case lexerPappyunstressed_vowel d1 of
        Parsed v d3 e3 ->
          Parsed ( i ++ [v] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParser_hyphen :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParser_hyphen d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyr d of
        Parsed r d3 e3 ->
          case lexerPappyconsonant d3 of
            Parsed _ _ e5 ->
              Parsed ( r ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyn d of
        Parsed n d3 e3 ->
          case lexerPappyr d3 of
            Parsed _ _ e5 ->
              Parsed ( n ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsefinal_syllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsefinal_syllable d =
  case lexerPappyonset d of
    Parsed o d1 e1 ->
      case lexerPappyy d1 of
        NoParse e3 ->
          case lexerPappystressed d1 of
            NoParse e5 ->
              case lexerPappynucleus d1 of
                Parsed n d7 e7 ->
                  case lexerPappycmene d7 of
                    NoParse e9 ->
                      case lexerPappypost_word d7 of
                        Parsed _ _ e11 ->
                          Parsed ( o ++ n ) d7 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsestressed_syllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsestressed_syllable d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappystressed d of
        Parsed _ _ e3 ->
          case lexerPappysyllable d of
            Parsed s d5 e5 ->
              Parsed ( s ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappysyllable d of
        Parsed s d3 e3 ->
          case lexerPappystress d3 of
            Parsed _ _ e5 ->
              Parsed ( s ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParsestressed_vowel :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsestressed_vowel d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappystressed d of
        Parsed _ _ e3 ->
          case lexerPappyvowel d of
            Parsed v d5 e5 ->
              Parsed ( v ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyvowel d of
        Parsed v d3 e3 ->
          case lexerPappystress d3 of
            Parsed _ _ e5 ->
              Parsed ( v ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseunstressed_syllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseunstressed_syllable d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappystressed d of
        NoParse e3 ->
          case lexerPappysyllable d of
            Parsed s d5 e5 ->
              case lexerPappystress d5 of
                NoParse e7 ->
                  Parsed ( s ) d5 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        Parsed _ _ e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyconsonantal_syllable d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyunstressed_vowel :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyunstressed_vowel d =
  case lexerPappystressed d of
    NoParse e1 ->
      case lexerPappyvowel d of
        Parsed v d3 e3 ->
          case lexerPappystress d3 of
            NoParse e5 ->
              Parsed ( v ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

lexerPappyParseStarRule9 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParseStarRule9 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyconsonant d of
        Parsed v d3 e3 ->
          case lexerPappyStarRule9 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappystress :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappystress d =
  case lexerPappyStarRule9 d of
    Parsed c d1 e1 ->
      case pappyResult3 of
        Parsed y d3 e3 ->
          case lexerPappysyllable d3 of
            Parsed s d5 e5 ->
              case lexerPappypause d5 of
                Parsed _ d7 e7 ->
                  Parsed ( c ++ ml y ++ s ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case lexerPappyy d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

lexerPappystressed :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappystressed d =
  case lexerPappyonset d of
    Parsed o d1 e1 ->
      case lexerPappyStarRule37 d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed v d5 e5 ->
              Parsed ( o ++ [v] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case lexerPappyChar d3 of
                    r @ (Parsed 'A' _ _) -> r
                    _ -> pappyAlt7_2 e7
                pappyAlt7_2 e7 =
                  case lexerPappyChar d3 of
                    r @ (Parsed 'E' _ _) -> r
                    _ -> pappyAlt7_3 e7
                pappyAlt7_3 e7 =
                  case lexerPappyChar d3 of
                    r @ (Parsed 'I' _ _) -> r
                    _ -> pappyAlt7_4 e7
                pappyAlt7_4 e7 =
                  case lexerPappyChar d3 of
                    r @ (Parsed 'O' _ _) -> r
                    _ -> pappyAlt7_5 e7
                pappyAlt7_5 e7 =
                  case lexerPappyChar d3 of
                    r @ (Parsed 'U' _ _) -> r
                    _ -> pappyAlt7_6 e7
                pappyAlt7_6 e7 = NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyany_syllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyany_syllable d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyonset d of
        Parsed o d3 e3 ->
          case lexerPappynucleus d3 of
            Parsed n d5 e5 ->
              case pappyResult7 of
                Parsed c d7 e7 ->
                  Parsed ( o ++ n ++ fromMaybe "" c ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case lexerPappycoda d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyconsonantal_syllable d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappysyllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappysyllable d =
  case lexerPappyonset d of
    Parsed o d1 e1 ->
      case lexerPappyy d1 of
        NoParse e3 ->
          case lexerPappynucleus d1 of
            Parsed n d5 e5 ->
              case pappyResult7 of
                Parsed c d7 e7 ->
                  Parsed ( o ++ n ++ fromMaybe "" c ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case lexerPappycoda d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseconsonantal_syllable :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseconsonantal_syllable d =
  case lexerPappyconsonant d of
    Parsed c d1 e1 ->
      case lexerPappysyllabic d1 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed _ _ e5 ->
              case pappyResult7 of
                Parsed c' d7 e7 ->
                  Parsed ( c : s : ml c' ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d3 e9
                  where
                    pappyResult9 =
                      case lexerPappyconsonant d3 of
                        Parsed cin d11 e11 ->
                          case lexerPappyspaces d11 of
                            Parsed _ _ e13 ->
                              Parsed ( c ) d11 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (lexerPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case lexerPappyconsonantal_syllable d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case lexerPappyonset d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsecoda :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsecoda d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyany_syllable d of
        NoParse e3 ->
          case lexerPappyconsonant d of
            Parsed c d5 e5 ->
              case lexerPappyany_syllable d5 of
                Parsed _ _ e7 ->
                  Parsed ( [c] ) d5 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        Parsed _ _ e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case lexerPappypause d5 of
                Parsed _ _ e7 ->
                  Parsed ( ml s ++ ml c ) d5 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case lexerPappyconsonant d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappysyllabic d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseonset :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseonset d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyh d of
        Parsed h d3 e3 ->
          Parsed ( [h] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed c d3 e3 ->
          case lexerPappyglide d3 of
            Parsed g d5 e5 ->
              Parsed ( ml c ++ [g] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappyconsonant d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case lexerPappyinitial d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappynucleus :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappynucleus d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyvowel d of
        Parsed v d3 e3 ->
          Parsed ( [v] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappydiphthong d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyy d of
        Parsed y d3 e3 ->
          Parsed ( [y] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappyParseglide :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParseglide d =
  case pappyResult1 of
    Parsed v d1 e1 ->
      case lexerPappynucleus d1 of
        Parsed _ _ e3 ->
          case lexerPappyglide d1 of
            NoParse e5 ->
              Parsed ( v ) d1 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappyi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case lexerPappyu d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

lexerPappyParsediphthong :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParsediphthong d =
  case pappyResult1 of
    Parsed d d1 e1 ->
      case lexerPappynucleus d1 of
        NoParse e3 ->
          case lexerPappyglide d1 of
            NoParse e5 ->
              Parsed ( d ) d1 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappya d of
            Parsed v d5 e5 ->
              case lexerPappyi d5 of
                Parsed w d7 e7 ->
                  Parsed ( [v, w] ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_2 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case lexerPappya d of
            Parsed v d5 e5 ->
              case lexerPappyu d5 of
                Parsed w d7 e7 ->
                  Parsed ( [v, w] ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_3 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case lexerPappye d of
            Parsed v d5 e5 ->
              case lexerPappyi d5 of
                Parsed w d7 e7 ->
                  Parsed ( [v, w] ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_4 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 =
          case lexerPappyo d of
            Parsed v d5 e5 ->
              case lexerPappyi d5 of
                Parsed w d7 e7 ->
                  Parsed ( [v, w] ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_5 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_5 (max e5 e3)
        pappyAlt3_5 e3 = NoParse e3

lexerPappyParsevowel :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsevowel d =
  case pappyResult1 of
    Parsed v d1 e1 ->
      case lexerPappynucleus d1 of
        NoParse e3 ->
          Parsed ( v ) d1 (max e3 e1)
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappya d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case lexerPappye d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case lexerPappyi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 =
          case lexerPappyo d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_5 (max e5 e3)
        pappyAlt3_5 e3 =
          case lexerPappyu d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_6 (max e5 e3)
        pappyAlt3_6 e3 = NoParse e3

lexerPappya :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappya d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed a d3 e3 ->
          Parsed ( a ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'a' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'A' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappye :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappye d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed e d3 e3 ->
          Parsed ( e ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'e' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'E' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyi :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyi d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed i d3 e3 ->
          Parsed ( i ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'i' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'I' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyo :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyo d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed o d3 e3 ->
          Parsed ( o ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'o' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'O' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyu :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyu d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed u d3 e3 ->
          Parsed ( u ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'u' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'U' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyy :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyy d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed y d3 e3 ->
          Parsed ( y ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'y' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'Y' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsePlusRule2 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParsePlusRule2 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyconsonant d of
        Parsed v d3 e3 ->
          case lexerPappyPlusRule2 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyconsonant d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappycluster :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappycluster d =
  case lexerPappyconsonant d of
    Parsed c d1 e1 ->
      case lexerPappyPlusRule2 d1 of
        Parsed cs d3 e3 ->
          Parsed ( c : cs ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseinitial_pair :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseinitial_pair d =
  case lexerPappyinitial d of
    Parsed _ _ e1 ->
      case lexerPappyconsonant d of
        Parsed c d3 e3 ->
          case lexerPappyconsonant d3 of
            Parsed d d5 e5 ->
              case lexerPappyconsonant d5 of
                NoParse e7 ->
                  Parsed ( [c, d] ) d5 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseinitial :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseinitial d =
  case pappyResult1 of
    Parsed i d1 e1 ->
      case lexerPappyconsonant d1 of
        NoParse e3 ->
          case lexerPappyglide d1 of
            NoParse e5 ->
              Parsed ( i ) d1 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappyaffricate d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case pappyResult5 of
            Parsed s d5 e5 ->
              case pappyResult7 of
                Parsed o d7 e7 ->
                  case pappyResult9 of
                    Parsed l d9 e9 ->
                      Parsed ( ml s ++ ml o ++ ml l ) d9 (maximum [e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_3 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case lexerPappyliquid d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_3 (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (lexerPappyPos d5) []) where
                        pappyAlt11_1 e11 =
                          case lexerPappyp d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_2 (max e13 e11)
                        pappyAlt11_2 e11 =
                          case lexerPappyt d5 of
                            Parsed t d13 e13 ->
                              case lexerPappyl d13 of
                                NoParse e15 ->
                                  Parsed ( t ) d13 (maximum [e15,e13,e11])
                                Parsed _ _ e15 -> pappyAlt11_3 (maximum [e15,e13,e11])
                            NoParse e13 -> pappyAlt11_3 (max e13 e11)
                        pappyAlt11_3 e11 =
                          case lexerPappyk d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_4 (max e13 e11)
                        pappyAlt11_4 e11 =
                          case lexerPappyf d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_5 (max e13 e11)
                        pappyAlt11_5 e11 =
                          case lexerPappyx d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_6 (max e13 e11)
                        pappyAlt11_6 e11 =
                          case lexerPappyb d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_7 (max e13 e11)
                        pappyAlt11_7 e11 =
                          case lexerPappyd d5 of
                            Parsed d d13 e13 ->
                              case lexerPappyl d13 of
                                NoParse e15 ->
                                  Parsed ( d ) d13 (maximum [e15,e13,e11])
                                Parsed _ _ e15 -> pappyAlt11_8 (maximum [e15,e13,e11])
                            NoParse e13 -> pappyAlt11_8 (max e13 e11)
                        pappyAlt11_8 e11 =
                          case lexerPappyg d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_9 (max e13 e11)
                        pappyAlt11_9 e11 =
                          case lexerPappyv d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_10 (max e13 e11)
                        pappyAlt11_10 e11 =
                          case lexerPappym d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_11 (max e13 e11)
                        pappyAlt11_11 e11 =
                          case lexerPappyn d5 of
                            Parsed n d13 e13 ->
                              case lexerPappyliquid d13 of
                                NoParse e15 ->
                                  Parsed ( n ) d13 (maximum [e15,e13,e11])
                                Parsed _ _ e15 -> pappyAlt11_12 (maximum [e15,e13,e11])
                            NoParse e13 -> pappyAlt11_12 (max e13 e11)
                        pappyAlt11_12 e11 = NoParse e11
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (lexerPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case lexerPappyc d of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case lexerPappys d of
                        Parsed s d11 e11 ->
                          case lexerPappyx d11 of
                            NoParse e13 ->
                              Parsed ( s ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 =
                      case pappyResult11 of
                        Parsed jz d11 e11 ->
                          case lexerPappyn d11 of
                            NoParse e13 ->
                              case lexerPappyliquid d11 of
                                NoParse e15 ->
                                  Parsed ( jz ) d11 (maximum [e15,e13,e11,e9])
                                Parsed _ _ e15 -> pappyAlt9_4 (maximum [e15,e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_4 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_4 (max e11 e9)
                      where
                        pappyResult11 =
                          pappyAlt13_1 (ParseError (lexerPappyPos d) []) where
                            pappyAlt13_1 e13 =
                              case lexerPappyj d of
                                Parsed v15 d15 e15 -> Parsed v15 d15 (max e15 e13)
                                NoParse e15 -> pappyAlt13_2 (max e15 e13)
                            pappyAlt13_2 e13 =
                              case lexerPappyz d of
                                Parsed v15 d15 e15 -> Parsed v15 d15 (max e15 e13)
                                NoParse e15 -> pappyAlt13_3 (max e15 e13)
                            pappyAlt13_3 e13 = NoParse e13
                    pappyAlt9_4 e9 = NoParse e9
        pappyAlt3_3 e3 = NoParse e3

lexerPappyaffricate :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyaffricate d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyt d of
        Parsed t d3 e3 ->
          case lexerPappyc d3 of
            Parsed c d5 e5 ->
              Parsed ( [t, c] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyt d of
        Parsed t d3 e3 ->
          case lexerPappys d3 of
            Parsed s d5 e5 ->
              Parsed ( [t, s] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyd d of
        Parsed d d3 e3 ->
          case lexerPappyj d3 of
            Parsed j d5 e5 ->
              Parsed ( [d, j] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case lexerPappyd d of
        Parsed d d3 e3 ->
          case lexerPappyz d3 of
            Parsed z d5 e5 ->
              Parsed ( [d, z] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 = NoParse e1

lexerPappyliquid :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyliquid d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyl d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyr d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyconsonant :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyconsonant d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyvoiced d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyunvoiced d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappysyllabic d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

lexerPappysyllabic :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappysyllabic d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyl d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappym d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyn d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case lexerPappyr d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 = NoParse e1

lexerPappyvoiced :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyvoiced d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyb d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyd d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyg d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case lexerPappyj d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case lexerPappyv d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case lexerPappyz d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 = NoParse e1

lexerPappyunvoiced :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyunvoiced d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyc d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyf d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case lexerPappyk d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case lexerPappyp d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case lexerPappys d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case lexerPappyt d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case lexerPappyx d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 = NoParse e1

lexerPappyParsel :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsel d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed l d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyl d3 of
                NoParse e7 ->
                  Parsed ( l ) d3 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'l' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'L' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsem :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsem d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed m d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappym d3 of
                NoParse e7 ->
                  case lexerPappyz d3 of
                    NoParse e9 ->
                      Parsed ( m ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'm' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'M' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsen :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsen d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyn d3 of
                NoParse e7 ->
                  case lexerPappyaffricate d3 of
                    NoParse e9 ->
                      Parsed ( n ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'n' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'N' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParser :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParser d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyr d3 of
                NoParse e7 ->
                  Parsed ( r ) d3 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'r' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'R' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParseb :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParseb d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed b d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyb d3 of
                NoParse e7 ->
                  case lexerPappyunvoiced d3 of
                    NoParse e9 ->
                      Parsed ( b ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'b' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'B' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsed :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsed d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed d d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyd d3 of
                NoParse e7 ->
                  case lexerPappyunvoiced d3 of
                    NoParse e9 ->
                      Parsed ( d ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'd' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'D' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParseg :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParseg d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed g d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyg d3 of
                NoParse e7 ->
                  case lexerPappyunvoiced d3 of
                    NoParse e9 ->
                      Parsed ( g ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'g' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'G' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsev :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsev d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyv d3 of
                NoParse e7 ->
                  case lexerPappyunvoiced d3 of
                    NoParse e9 ->
                      Parsed ( v ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'v' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'V' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsej :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsej d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed j d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyj d3 of
                NoParse e7 ->
                  case lexerPappyz d3 of
                    NoParse e9 ->
                      case lexerPappyunvoiced d3 of
                        NoParse e11 ->
                          Parsed ( j ) d3 (maximum [e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'j' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'J' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsez :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsez d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed z d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyz d3 of
                NoParse e7 ->
                  case lexerPappyj d3 of
                    NoParse e9 ->
                      case lexerPappyunvoiced d3 of
                        NoParse e11 ->
                          Parsed ( z ) d3 (maximum [e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'z' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'Z' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParses :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParses d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappys d3 of
                NoParse e7 ->
                  case lexerPappyc d3 of
                    NoParse e9 ->
                      case lexerPappyvoiced d3 of
                        NoParse e11 ->
                          Parsed ( s ) d3 (maximum [e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 's' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'S' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsec :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsec d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed c d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyc d3 of
                NoParse e7 ->
                  case lexerPappys d3 of
                    NoParse e9 ->
                      case lexerPappyx d3 of
                        NoParse e11 ->
                          case lexerPappyvoiced d3 of
                            NoParse e13 ->
                              Parsed ( c ) d3 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            Parsed _ _ e13 -> NoParse (maximum [e13,e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'c' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'C' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsex :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsex d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed x d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyx d3 of
                NoParse e7 ->
                  case lexerPappyc d3 of
                    NoParse e9 ->
                      case lexerPappyk d3 of
                        NoParse e11 ->
                          case lexerPappyvoiced d3 of
                            NoParse e13 ->
                              Parsed ( x ) d3 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            Parsed _ _ e13 -> NoParse (maximum [e13,e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'x' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'X' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsek :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsek d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed k d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyk d3 of
                NoParse e7 ->
                  case lexerPappyx d3 of
                    NoParse e9 ->
                      case lexerPappyvoiced d3 of
                        NoParse e11 ->
                          Parsed ( k ) d3 (maximum [e11,e9,e7,e5,e3,e1])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'k' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'K' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsef :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsef d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed f d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyf d3 of
                NoParse e7 ->
                  case lexerPappyvoiced d3 of
                    NoParse e9 ->
                      Parsed ( f ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'f' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'F' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsep :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsep d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed p d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyp d3 of
                NoParse e7 ->
                  case lexerPappyvoiced d3 of
                    NoParse e9 ->
                      Parsed ( p ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'p' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'P' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParset :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParset d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed t d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappyt d3 of
                NoParse e7 ->
                  case lexerPappyvoiced d3 of
                    NoParse e9 ->
                      Parsed ( t ) d3 (maximum [e9,e7,e5,e3,e1])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 't' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'T' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyh :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyh d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed h d3 e3 ->
          case lexerPappynucleus d3 of
            Parsed _ _ e5 ->
              Parsed ( h ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed 'h' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '\'' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappyParsedigit :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyParsedigit d =
  case lexerPappyStarRule37 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed d d3 e3 ->
          case lexerPappyh d3 of
            NoParse e5 ->
              case lexerPappynucleus d3 of
                NoParse e7 ->
                  Parsed ( d ) d3 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> NoParse (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '0' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '1' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '2' _ _) -> r
                _ -> pappyAlt5_4 e5
            pappyAlt5_4 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '3' _ _) -> r
                _ -> pappyAlt5_5 e5
            pappyAlt5_5 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '4' _ _) -> r
                _ -> pappyAlt5_6 e5
            pappyAlt5_6 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '5' _ _) -> r
                _ -> pappyAlt5_7 e5
            pappyAlt5_7 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '6' _ _) -> r
                _ -> pappyAlt5_8 e5
            pappyAlt5_8 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '7' _ _) -> r
                _ -> pappyAlt5_9 e5
            pappyAlt5_9 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '8' _ _) -> r
                _ -> pappyAlt5_10 e5
            pappyAlt5_10 e5 =
              case lexerPappyChar d1 of
                r @ (Parsed '9' _ _) -> r
                _ -> pappyAlt5_11 e5
            pappyAlt5_11 e5 = NoParse e5
    NoParse e1 -> NoParse e1

lexerPappypost_word :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappypost_word d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappypause d of
        Parsed _ d3 e3 ->
          Parsed ( "" ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappynucleus d of
        NoParse e3 ->
          case lexerPappylojban_word d of
            Parsed l d5 e5 ->
              Parsed ( l ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        Parsed _ _ e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappypause :: LexerPappyDerivs -> Result LexerPappyDerivs ( String )
lexerPappypause d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyStarRule37 d of
        Parsed cs d3 e3 ->
          case lexerPappyspace_char d3 of
            Parsed s d5 e5 ->
              Parsed ( cs ++ [s] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyanyChar d of
        NoParse e3 ->
          Parsed ( "" ) d (max e3 e1)
        Parsed _ _ e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyanyChar :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappyanyChar d =
  case lexerPappyChar d of
    Parsed c d1 e1 ->
      case ( True ) of
        True ->
          Parsed ( c ) d1 e1
        False -> NoParse e1
    NoParse e1 -> NoParse e1

lexerPappyParsePlusRule3 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParsePlusRule3 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappynon_space d of
        Parsed v d3 e3 ->
          case lexerPappyPlusRule3 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappynon_space d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappynon_space :: LexerPappyDerivs -> Result LexerPappyDerivs (Char)
lexerPappynon_space d =
  case lexerPappyspace_char d of
    NoParse e1 ->
      case lexerPappyanyChar d of
        Parsed c d3 e3 ->
          Parsed ( c ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

lexerPappyspace_char :: LexerPappyDerivs -> Result LexerPappyDerivs ( Char )
lexerPappyspace_char d =
  case pappyResult1 of
    Parsed c d1 e1 ->
      Parsed ( c ) d1 e1
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (lexerPappyPos d) []) where
        pappyAlt3_1 e3 =
          case lexerPappyChar d of
            r @ (Parsed '.' _ _) -> r
            _ -> pappyAlt3_2 e3
        pappyAlt3_2 e3 =
          case lexerPappyChar d of
            r @ (Parsed '?' _ _) -> r
            _ -> pappyAlt3_3 e3
        pappyAlt3_3 e3 =
          case lexerPappyChar d of
            r @ (Parsed '!' _ _) -> r
            _ -> pappyAlt3_4 e3
        pappyAlt3_4 e3 =
          case lexerPappyChar d of
            r @ (Parsed ' ' _ _) -> r
            _ -> pappyAlt3_5 e3
        pappyAlt3_5 e3 =
          case lexerPappyChar d of
            r @ (Parsed '\t' _ _) -> r
            _ -> pappyAlt3_6 e3
        pappyAlt3_6 e3 =
          case lexerPappyChar d of
            r @ (Parsed '\r' _ _) -> r
            _ -> pappyAlt3_7 e3
        pappyAlt3_7 e3 =
          case lexerPappyChar d of
            r @ (Parsed '\n' _ _) -> r
            _ -> pappyAlt3_8 e3
        pappyAlt3_8 e3 = NoParse e3

lexerPappyParsespaces :: LexerPappyDerivs -> Result LexerPappyDerivs ( String )
lexerPappyParsespaces d =
  case lexerPappyY d of
    NoParse e1 ->
      case pappyResult3 of
        Parsed i d3 e3 ->
          Parsed ( i ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappyPlusRule4 d of
                Parsed csy d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      Parsed ( concat csy ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case lexerPappyanyChar d7 of
                            NoParse e13 ->
                              Parsed ( () ) d7 e13
                            Parsed _ _ e13 -> NoParse e13
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyanyChar d of
                NoParse e7 ->
                  Parsed ( "" ) d (max e7 e5)
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    Parsed _ _ e1 -> NoParse e1

lexerPappyParsePlusRule4 :: LexerPappyDerivs -> Result LexerPappyDerivs ([ String ])
lexerPappyParsePlusRule4 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyPlusRule4 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappycomma_space_char d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyybu d of
                NoParse e7 ->
                  case lexerPappyY d of
                    Parsed y d9 e9 ->
                      Parsed ( y ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (lexerPappyPos d) []) where
            pappyAlt5_1 e5 =
              case lexerPappycomma_space_char d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case lexerPappyybu d of
                NoParse e7 ->
                  case lexerPappyY d of
                    Parsed y d9 e9 ->
                      Parsed ( y ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseStarRule37 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParseStarRule37 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case lexerPappyStarRule37 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case lexerPappyChar d of
            r @ (Parsed ',' _ _) -> r
            _ -> NoParse (ParseError (lexerPappyPos d) [])
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappycomma_space_char :: LexerPappyDerivs -> Result LexerPappyDerivs ( String )
lexerPappycomma_space_char d =
  case lexerPappyStarRule37 d of
    Parsed c d1 e1 ->
      case lexerPappyspace_char d1 of
        Parsed s d3 e3 ->
          Parsed ( c ++ [s] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParseStarRule38 :: LexerPappyDerivs -> Result LexerPappyDerivs ([ Char ])
lexerPappyParseStarRule38 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyspace_char d of
        Parsed v d3 e3 ->
          case lexerPappyStarRule38 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

lexerPappyParseybu :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyParseybu d =
  case lexerPappyY d of
    Parsed y d1 e1 ->
      case lexerPappyStarRule38 d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed b d5 e5 ->
              Parsed ( y ++ b ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case lexerPappycmavo d3 of
                Parsed _ _ e7 ->
                  case pappyResult9 of
                    Parsed bu d9 e9 ->
                      Parsed ( bu ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case lexerPappyb d3 of
                        Parsed b d11 e11 ->
                          case lexerPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [b, u] ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
                NoParse e7 -> NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsePlusRule5 :: LexerPappyDerivs -> Result LexerPappyDerivs ([Char])
lexerPappyParsePlusRule5 d =
  pappyAlt1_1 (ParseError (lexerPappyPos d) []) where
    pappyAlt1_1 e1 =
      case lexerPappyy d of
        Parsed v d3 e3 ->
          case lexerPappyPlusRule5 d3 of
            Parsed vs d5 e5 ->
              Parsed (v : vs) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case lexerPappyy d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

lexerPappyY :: LexerPappyDerivs -> Result LexerPappyDerivs (String)
lexerPappyY d =
  case lexerPappycmavo d of
    Parsed _ _ e1 ->
      case lexerPappyPlusRule5 d of
        Parsed y d3 e3 ->
          case lexerPappypost_word d3 of
            Parsed _ _ e5 ->
              Parsed ( y ) d3 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

lexerPappyParsedummyTail :: LexerPappyDerivs -> Result LexerPappyDerivs ((() -> ()))
lexerPappyParsedummyTail d =
  case lexerPappyChar d of
    Parsed 'a' d1 _ ->
      case lexerPappydummy d1 of
        Parsed _ d3 e3 ->
          case lexerPappydummyTail d3 of
            Parsed pappyTail d5 e5 ->
              Parsed (\l -> pappyTail ( () )) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3
    _ ->
      Parsed (\v -> v) d (ParseError (lexerPappyPos d) [])

lexerPappyParsedummy :: LexerPappyDerivs -> Result LexerPappyDerivs (())
lexerPappyParsedummy d =
  case pappyResult1 of
    Parsed l d1 e1 ->
      case lexerPappydummyTail d1 of
        Parsed t d3 e3 ->
          Parsed (t l) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case lexerPappyChar d of
        Parsed 'a' d3 _ ->
          case lexerPappydummy d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 e5
            NoParse e5 -> NoParse e5
        _ -> NoParse (ParseError (lexerPappyPos d) [])