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

import Pos
import Parse


import System.Environment
import Data.Maybe
import Data.Data
import Preprocess

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
	= Selbri Selbri
	| SelbriTailTerms Selbri [Term] (Maybe Clause) [Free]
	| GekSentence Gek Sentence Gik Sentence [Term] (Maybe Clause) [Free]
	| KEGekSentence (Maybe Tag) Clause [Free] Sentence (Maybe Clause) [Free]
	| NAGekSentence Clause [Free] Sentence
	| 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
	| PrenexSentence [Term] Clause [Free] Sentence
	| TUhE (Maybe Tag) Clause [Free] Text (Maybe Clause) [Free]
	| IBOStatement Statement Clause (Maybe JoikJek) (Maybe Tag) Clause [Free]
		Statement
	| IBO Statement Clause (Maybe JoikJek) (Maybe Tag) Clause [Free]
	| IJoikJek Statement [(Clause, JoikJek, [Free], Maybe Statement)]
	| Prenex [Term] Clause [Free] Statement
	| FPrenex [Term] Clause [Free]
	| FTermsVAU [Term] (Maybe Clause) [Free]
	| FEk Ek [Free]
	| FGihek Gihek [Free]
	| FQuantifier Quantifier
	| FNA Clause [Free]
	| FRelativeClause RelativeClause
	| FLinks Links
	| FLinkargs Linkargs
	| 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 (Eq, Show, Data, Typeable)

data Sumti
	= TermsPEhETerms Term [(Clause, [Free], JoikJek, [Free], Term)]
	| TermCEhETerm Term [(Clause, [Free], Term)]
	| TagSumti Tag Sumti
	| KU (Maybe Clause) [Free]
	| NAKU Clause Clause [Free]
	| NUhIGek Clause [Free] Gek [Term] (Maybe Clause) [Free] Gik [Term]
		(Maybe Clause) [Free]
	| NUhI Clause [Free] [Term] (Maybe Clause) [Free]
	| Gek Gek TermsGikTerms
	| ZO [String] String String Indicators [Free]
	| ZOI [String] String [String] Indicators [Free]
	| 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 (Eq, Show, Data, Typeable)

data TermsGikTerms
	= TGT Term TermsGikTerms Term
	| Gik Gik
	deriving (Eq, Show, Data, Typeable)

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

data Selbri
	= Brivla Clause [Free]
	| GOhA Clause (Maybe Clause) [Free]
	| KE Clause [Free] Selbri (Maybe Clause) [Free]
	| ME Clause [Free] Sumti (Maybe Clause) [Free] (Maybe Clause) [Free]
	| MOI NumberLerfuString Clause [Free]
	| NUhA Clause [Free] MexOperator
	| SE Clause [Free] Selbri
	| JAI Clause [Free] (Maybe Tag) Selbri
	| NAhE Clause [Free] Selbri
	| 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
	| NU Clause (Maybe Clause) [Free]
		[(JoikJek, [Free], Clause, Maybe Clause, [Free])]
		Sentence (Maybe Clause) [Free]
	deriving (Eq, Show, Data, Typeable)

type RelativeClauses = RelativeClause

data RelativeClause
	= GOI Clause [Free] Term (Maybe Clause) [Free]
	| NOI Clause [Free] Sentence (Maybe Clause) [Free]
	| RelativeClauseZIhE RelativeClause [(Clause, [Free], RelativeClause)]
	deriving (Eq, Show, Data, Typeable)

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

data Linkargs
	= BE Clause [Free] Term (Maybe Links) (Maybe Clause) [Free]
	deriving (Eq, Show, Data, Typeable)
data Links
	= BEI Clause [Free] Term (Maybe Links)
	deriving (Eq, Show, Data, Typeable)

type Quantifier = Operand
type Mex = Operand
data MexOperator
	= VUhU Clause [Free]
	| NAhU Clause [Free] Selbri (Maybe Clause) [Free]
	| MAhO Clause [Free] Mex (Maybe Clause) [Free]
	| NAhEOperator Clause [Free] MexOperator
	| SEOperator Clause [Free] MexOperator
	| KEOperator Clause [Free] MexOperator (Maybe Clause) [Free]
	| GuhekOperator Guhek MexOperator Gik MexOperator
	| JekJoikBOOperator MexOperator JoikJek (Maybe Tag) Clause [Free] MexOperator
	| JoikJekJoikKEOperator MexOperator
		[Either (JoikJek, [Free], MexOperator)
			(Joik, Maybe Tag, Clause, [Free], MexOperator,
				Maybe Clause, [Free])]
	deriving (Eq, Show, Data, Typeable)

data Operand
	= OLerfuString LerfuString (Maybe Clause) [Free]
	| OperandJoikEkBO Operand JoikEk [Free] (Maybe Tag) Clause [Free] Operand
	| OperandJoikEk Operand [(JoikEk, [Free], Operand)]
	| OperandJoikEkKE Operand JoikEk [Free] (Maybe Tag) Clause [Free] Operand
		(Maybe Clause) [Free]
	| MexOperatorMex Mex [(MexOperator, Mex)]
	| FUhA Clause [Free] RPExpression
	| PEhO (Maybe Clause) [Free] MexOperator [Mex] (Maybe Clause) [Free]
	| BIhE Mex Clause [Free] MexOperator Mex
	| VEI Clause [Free] Mex (Maybe Clause) [Free]
	| Number Number (Maybe Clause) [Free]
	| NIhE Clause [Free] Selbri (Maybe Clause) [Free]
	| MOhE Clause [Free] Sumti (Maybe Clause) [Free]
	| JOhI Clause [Free] [Mex] (Maybe Clause) [Free]
	| GekOperand Gek Operand Gik Operand
	| LAhE_NAhEOperand Clause (Maybe Clause) [Free] Operand (Maybe Clause) [Free]
	deriving (Eq, Show, Data, Typeable)

data RPExpression
	= RPExpression Operand (Maybe RPExpressionTail)
	deriving (Eq, Show, Data, Typeable)
data RPExpressionTail
	= RPExpressionTail RPExpression MexOperator (Maybe RPExpressionTail)
	deriving (Eq, Show, Data, Typeable)

type NumberLerfuString = [Clause]
type Number = [Clause]
type LerfuString = [Clause]

data Free
	= VocativeSumti [Clause] (Maybe Sumti) (Maybe Clause)
	| XINumber Clause [Free] NumberLerfuString (Maybe Clause)
	| XIMex Clause [Free] Clause [Free] Mex (Maybe Clause)
	| SEI Clause [Free] (Maybe ([Term], Maybe Clause, [Free])) Selbri (Maybe Clause)
	| SOI Clause [Free] Sumti (Maybe Sumti) (Maybe Clause)
	| TO Clause Text (Maybe Clause)
	| MAI NumberLerfuString Clause
	| VocativeSelbri [Clause] (Maybe RelativeClauses) Selbri
		(Maybe RelativeClauses) (Maybe Clause)
	| VocativeCmene [Clause] (Maybe RelativeClauses) [Clause] [Free]
		(Maybe RelativeClauses) (Maybe Clause)
	deriving (Eq, Show, Data, Typeable)

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)
	| BIhI (Maybe Clause) Clause (Maybe Clause)
	| GAhO Clause JoikJek Clause
	deriving (Eq, Show, Data, Typeable)
data Gek
	= GA (Maybe Clause) Clause (Maybe Clause) [Free]
	| JoikGI Joik Clause [Free]
	| STagGik Tag Gik
	deriving (Eq, Show, Data, Typeable)
-- type Guhek = ([Clause], [Free])
-- type Gik = ([Clause], [Free])
type Guhek = (Maybe Clause, Clause, Maybe Clause, [Free])
type Gik = (Clause, Maybe Clause, [Free])

type Tense = Tag
data IntervalProperty
	= ROI Number Clause (Maybe Clause)
	| TAhE Clause (Maybe Clause)
	| ZAhO Clause (Maybe Clause)
	deriving (Eq, Show, Data, Typeable)

data Tag
	= BAI (Maybe Clause) (Maybe Clause) Clause (Maybe Clause) (Maybe Clause)
	| FA Clause [Free]
	| KI Clause
	| CUhE Clause
	| Time (Maybe Clause) [(Clause, Maybe Clause, Maybe Clause)]
		(Maybe (Clause, Maybe (Clause, Maybe Clause))) [IntervalProperty]
	| Space (Maybe Clause) [SpaceOffset] (Maybe SpaceInterval) (Maybe (Clause, SpaceOffset))
	| SpaceTime Tense Tense
	| TimeSpace Tense Tense
	| TenseCAhA Tense Clause
	| CAhA Clause
	| NAhETenseKI (Maybe Clause) Tense (Maybe Clause)
	| SimpleTenseModalFree Tag [Free]
	| FIhO Clause [Free] Selbri (Maybe Clause) [Free]
	| JoikJekTag Tag [(JoikJek, [Free], Tag)]
	| JekJoikSTag Tag [(JoikJek, Tag)]
	deriving (Eq, Show, Data, Typeable)

data SpaceInterval
	= FEhE [(Clause, IntervalProperty)]
	| VEhAVIhA (Maybe Clause) (Maybe Clause)
	| VEhAVIhAFAhA (Maybe Clause) (Maybe Clause) Clause (Maybe Clause)
	| VEhAVIhAFEhE (Maybe Clause) (Maybe Clause) SpaceInterval
	| VEhAVIhAFAhAFEhE (Maybe Clause) (Maybe Clause) Clause (Maybe Clause) SpaceInterval
	deriving (Eq, Show, Data, Typeable)

data SpaceOffset
	= FAhA Clause (Maybe Clause) (Maybe Clause)
	deriving (Eq, Show, Data, Typeable)

{-
main = do
	[str] <- getArgs
	let p = fromMaybe (error "can't lex") $ preprocess str
	case testPappytest $ testPappyParse "test" p 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 (Maybe b) -> Maybe b
fromRight = either (const $ Nothing) id



data TestPappyDerivs = TestPappyDerivs {
	testPappySub0 :: TestPappyDerivs0,
	testPappySub1 :: TestPappyDerivs1,
	testPappySub2 :: TestPappyDerivs2,
	testPappySub3 :: TestPappyDerivs3,
	testPappySub4 :: TestPappyDerivs4,
	testPappySub5 :: TestPappyDerivs5,
	testPappySub6 :: TestPappyDerivs6,
	testPappySub7 :: TestPappyDerivs7,
	testPappySub8 :: TestPappyDerivs8,
	testPappyChar :: Result TestPappyDerivs Char,
	testPappyPos :: Pos
}

instance Derivs TestPappyDerivs where
	dvChar d = testPappyChar d
	dvPos d = testPappyPos d

data TestPappyDerivs0 = TestPappyDerivs0 {
	testPappySubStarRule0 :: Result TestPappyDerivs ([Clause]),
	testPappySubtext :: Result TestPappyDerivs (Text),
	testPappySubStarRule3 :: Result TestPappyDerivs ([ () ]),
	testPappySubtext_1 :: Result TestPappyDerivs (Text),
	testPappySubparagraphs :: Result TestPappyDerivs (Paragraphs),
	testPappySubPlusRule2 :: Result TestPappyDerivs ([Clause]),
	testPappySubStarRule8 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule9 :: Result TestPappyDerivs ([ (Clause, [Free], Maybe Statement) ]),
	testPappySubstatement :: Result TestPappyDerivs (Statement),
	testPappySubStarRule11 :: Result TestPappyDerivs ([ (Clause, JoikJek, [Free], Maybe Statement) ]),
	testPappySubstatement_2 :: Result TestPappyDerivs (Statement),
	testPappySubfragment :: Result TestPappyDerivs (Fragment),
	testPappySubsentence :: Result TestPappyDerivs (Sentence),
	testPappySubStarRule21 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule23 :: Result TestPappyDerivs ([ () ]),
	testPappySubsubsentence :: Result TestPappyDerivs (Sentence),
	testPappySubbridi_tail :: Result TestPappyDerivs (Sentence),
	testPappySubStarRule26 :: Result TestPappyDerivs ([ () ]),
	testPappySubbridi_tail_start :: Result TestPappyDerivs ( () ),
	testPappySubStarRule27 :: Result TestPappyDerivs ([ (Gihek, [Free], Sentence, [Term], Maybe Clause, [Free]) ]),
	testPappySubbridi_tail_2 :: Result TestPappyDerivs (Sentence),
	testPappySubgek_sentence :: Result TestPappyDerivs (Sentence),
	testPappySubPlusRule3 :: Result TestPappyDerivs ([Term]),
	testPappySubStarRule34 :: Result TestPappyDerivs ([ (Clause, [Free], JoikJek, [Free], Term) ]),
	testPappySubStarRule35 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule37 :: Result TestPappyDerivs ([ (Clause, [Free], Term) ]),
	testPappySubStarRule38 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule40 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule41 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule42 :: Result TestPappyDerivs ([ () ]),
	testPappySubterm_1 :: Result TestPappyDerivs (Term),
	testPappySubStarRule46 :: Result TestPappyDerivs ([ () ]),
	testPappySubterm_start :: Result TestPappyDerivs ( () )}

data TestPappyDerivs1 = TestPappyDerivs1 {
	testPappySubterms_gik_terms :: Result TestPappyDerivs (TermsGikTerms),
	testPappySubsumti :: Result TestPappyDerivs (Sumti),
	testPappySubStarRule55 :: Result TestPappyDerivs ([ (JoikEk, [Free], Sumti) ]),
	testPappySubsumti_3 :: Result TestPappyDerivs (Sumti),
	testPappySubsumti_4 :: Result TestPappyDerivs (Sumti),
	testPappySubsumti_6 :: Result TestPappyDerivs (Sumti),
	testPappySubLAhE_NAhE :: Result TestPappyDerivs ( (Clause, Maybe Clause, [Free]) ),
	testPappySubStarRule73 :: Result TestPappyDerivs ([ (Clause, [Free], RelativeClause) ]),
	testPappySubStarRule75 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule76 :: Result TestPappyDerivs ([ () ]),
	testPappySubrelative_clause_1 :: Result TestPappyDerivs (RelativeClause),
	testPappySubselbri :: Result TestPappyDerivs (Selbri),
	testPappySubselbri_2 :: Result TestPappyDerivs (Selbri),
	testPappySubPlusRule5 :: Result TestPappyDerivs ([Selbri]),
	testPappySubStarRule83 :: Result TestPappyDerivs ([JoikJekSelbri5]),
	testPappySubselbri_5 :: Result TestPappyDerivs (Selbri),
	testPappySubselbri_6 :: Result TestPappyDerivs (Selbri),
	testPappySubStarRule89 :: Result TestPappyDerivs ([ (Clause, [Free], Selbri) ]),
	testPappySubStarRule104 :: Result TestPappyDerivs ([ (JoikJek, [Free], Clause, Maybe Clause, [Free]) ]),
	testPappySubtanru_unit_2 :: Result TestPappyDerivs (Selbri),
	testPappySubStarRule107 :: Result TestPappyDerivs ([ () ]),
	testPappySublinkargs_1 :: Result TestPappyDerivs (Linkargs),
	testPappySubStarRule110 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule111 :: Result TestPappyDerivs ([ () ]),
	testPappySublinks_1 :: Result TestPappyDerivs (Links),
	testPappySubStarRule113 :: Result TestPappyDerivs ([ () ]),
	testPappySubquantifier :: Result TestPappyDerivs (Quantifier),
	testPappySubStarRule117 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule118 :: Result TestPappyDerivs ([ (MexOperator, Mex) ]),
	testPappySubmex_0 :: Result TestPappyDerivs (Mex),
	testPappySubStarRule119 :: Result TestPappyDerivs ([ () ]),
	testPappySubmex_start :: Result TestPappyDerivs ( () ),
	testPappySubmex_1 :: Result TestPappyDerivs (Mex)}

data TestPappyDerivs2 = TestPappyDerivs2 {
	testPappySubmex_2 :: Result TestPappyDerivs (Mex),
	testPappySubrp_expression_tail :: Result TestPappyDerivs ( Maybe RPExpressionTail),
	testPappySubStarRule124 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule125 :: Result TestPappyDerivs ([ Either (JoikJek, [Free], MexOperator) (Joik, Maybe Tag, Clause, [Free], MexOperator, Maybe Clause, [Free]) ]),
	testPappySubStarRule128 :: Result TestPappyDerivs ([ () ]),
	testPappySuboperator_start :: Result TestPappyDerivs ( () ),
	testPappySuboperator_1 :: Result TestPappyDerivs (MexOperator),
	testPappySuboperator_2 :: Result TestPappyDerivs (MexOperator),
	testPappySubmex_operator :: Result TestPappyDerivs (MexOperator),
	testPappySubStarRule139 :: Result TestPappyDerivs ([ () ]),
	testPappySuboperand_0 :: Result TestPappyDerivs (Operand),
	testPappySubStarRule142 :: Result TestPappyDerivs ([ () ]),
	testPappySuboperand_start :: Result TestPappyDerivs ( () ),
	testPappySubStarRule143 :: Result TestPappyDerivs ([ (JoikEk, [Free], Operand) ]),
	testPappySuboperand_2 :: Result TestPappyDerivs (Operand),
	testPappySubPlusRule7 :: Result TestPappyDerivs ([Mex]),
	testPappySuboperand_3 :: Result TestPappyDerivs (Operand),
	testPappySubStarRule154 :: Result TestPappyDerivs ([ [Clause] ]),
	testPappySublerfu_word :: Result TestPappyDerivs ( [Clause] ),
	testPappySubek :: Result TestPappyDerivs (Ek),
	testPappySubStarRule155 :: Result TestPappyDerivs ([ () ]),
	testPappySubgihek_1 :: Result TestPappyDerivs (Gihek),
	testPappySubStarRule156 :: Result TestPappyDerivs ([ () ]),
	testPappySubjek :: Result TestPappyDerivs (Jek),
	testPappySubjoik :: Result TestPappyDerivs (Joik),
	testPappySubinterval :: Result TestPappyDerivs (Joik),
	testPappySubStarRule157 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule160 :: Result TestPappyDerivs ([ () ]),
	testPappySubgek :: Result TestPappyDerivs (Gek),
	testPappySubguhek :: Result TestPappyDerivs (Guhek),
	testPappySubgik :: Result TestPappyDerivs (Gik),
	testPappySubStarRule168 :: Result TestPappyDerivs ([ (JoikJek, Tag) ]),
	testPappySubStarRule169 :: Result TestPappyDerivs ([ (JoikJek, [Free], Tag) ])}

data TestPappyDerivs3 = TestPappyDerivs3 {
	testPappySubtense_modal :: Result TestPappyDerivs (Tag),
	testPappySubsimple_tense_modal :: Result TestPappyDerivs (Tag),
	testPappySubPlusRule8 :: Result TestPappyDerivs ([ (Clause, Maybe Clause, Maybe Clause) ]),
	testPappySubStarRule177 :: Result TestPappyDerivs ([IntervalProperty]),
	testPappySubStarRule178 :: Result TestPappyDerivs ([ (Clause, Maybe Clause, Maybe Clause) ]),
	testPappySubPlusRule9 :: Result TestPappyDerivs ([IntervalProperty]),
	testPappySubtime :: Result TestPappyDerivs (Tense),
	testPappySubzeha_pu :: Result TestPappyDerivs ( (Clause, Maybe (Clause, Maybe Clause)) ),
	testPappySubtime_offset :: Result TestPappyDerivs ( (Clause, Maybe Clause, Maybe Clause) ),
	testPappySubPlusRule10 :: Result TestPappyDerivs ([SpaceOffset]),
	testPappySubStarRule181 :: Result TestPappyDerivs ([SpaceOffset]),
	testPappySubspace :: Result TestPappyDerivs (Tense),
	testPappySubspace_offset :: Result TestPappyDerivs (SpaceOffset),
	testPappySubspace_interval :: Result TestPappyDerivs (SpaceInterval),
	testPappySubVEhA_VIhA :: Result TestPappyDerivs ( (Maybe Clause, Maybe Clause) ),
	testPappySubPlusRule11 :: Result TestPappyDerivs ([ (Clause, IntervalProperty) ]),
	testPappySubinterval_property :: Result TestPappyDerivs (IntervalProperty),
	testPappySubPlusRule12 :: Result TestPappyDerivs ([Clause]),
	testPappySubStarRule188 :: Result TestPappyDerivs ([Free]),
	testPappySubPlusRule13 :: Result TestPappyDerivs ([ [([String], String, Indicators)] ]),
	testPappySubStarRule189 :: Result TestPappyDerivs ([ [([String], String, Indicators)] ]),
	testPappySubvocative :: Result TestPappyDerivs ( [([String], String, Indicators)] ),
	testPappySubcoi_nai :: Result TestPappyDerivs ( [([String], String, Indicators)] ),
	testPappySubPlusRule14 :: Result TestPappyDerivs ([ [([String], String)] ]),
	testPappySubindicator :: Result TestPappyDerivs ( [([String], String)] ),
	testPappySubStarRule190 :: Result TestPappyDerivs ([String]),
	testPappySubStarRule191 :: Result TestPappyDerivs ([String]),
	testPappySubPlusRule15 :: Result TestPappyDerivs ([ String ]),
	testPappySubPlusRule16 :: Result TestPappyDerivs ([Pre]),
	testPappySubpre_zei_bu :: Result TestPappyDerivs ( String ),
	testPappySubStarRule192 :: Result TestPappyDerivs ([Char]),
	testPappySubStarRule193 :: Result TestPappyDerivs ([ [([String], String)] ]),
	testPappySubany_word_SA_handling :: Result TestPappyDerivs ( ([String], String) )}

data TestPappyDerivs4 = TestPappyDerivs4 {
	testPappySubStarRule194 :: Result TestPappyDerivs ([ () ]),
	testPappySubPlusRule17 :: Result TestPappyDerivs ([ () ]),
	testPappySubsi_clause_single :: Result TestPappyDerivs ( () ),
	testPappySuberasable_clause :: Result TestPappyDerivs ( () ),
	testPappySubBRIVLA_pre :: Result TestPappyDerivs ( ([String], String) ),
	testPappySubPlusRule18 :: Result TestPappyDerivs ([String]),
	testPappySubStarRule195 :: Result TestPappyDerivs ([ () ]),
	testPappySubStarRule196 :: Result TestPappyDerivs ([String]),
	testPappySubStarRule198 :: Result TestPappyDerivs ([String]),
	testPappySubPlusRule19 :: Result TestPappyDerivs ([String]),
	testPappySubcmene :: Result TestPappyDerivs (String),
	testPappySubStarRule200 :: Result TestPappyDerivs ([Char]),
	testPappySubcmavo :: Result TestPappyDerivs (String),
	testPappySubStarRule202 :: Result TestPappyDerivs ([String]),
	testPappySubStarRule203 :: Result TestPappyDerivs ([String]),
	testPappySubstressed_extended_rafsi :: Result TestPappyDerivs (String),
	testPappySubextended_rafsi :: Result TestPappyDerivs (String),
	testPappySubStarRule205 :: Result TestPappyDerivs ([String]),
	testPappySubStarRule206 :: Result TestPappyDerivs ([String]),
	testPappySubbrivla_head :: Result TestPappyDerivs (String),
	testPappySubStarRule207 :: Result TestPappyDerivs ([String]),
	testPappySubCVV_final_rafsi :: Result TestPappyDerivs (String),
	testPappySubshort_final_rafsi :: Result TestPappyDerivs (String),
	testPappySubstressed_y_rafsi :: Result TestPappyDerivs (String),
	testPappySubstressed_y_less_rafsi :: Result TestPappyDerivs (String),
	testPappySubstressed_long_rafsi :: Result TestPappyDerivs (String),
	testPappySuby_rafsi :: Result TestPappyDerivs (String),
	testPappySuby_less_rafsi :: Result TestPappyDerivs (String),
	testPappySubr_hyphen :: Result TestPappyDerivs (Char),
	testPappySubfinal_syllable :: Result TestPappyDerivs (String),
	testPappySubstressed_syllable :: Result TestPappyDerivs (String),
	testPappySubstressed_vowel :: Result TestPappyDerivs (Char),
	testPappySubunstressed_syllable :: Result TestPappyDerivs (String)}

data TestPappyDerivs5 = TestPappyDerivs5 {
	testPappySubStarRule208 :: Result TestPappyDerivs ([Char]),
	testPappySubconsonantal_syllable :: Result TestPappyDerivs (String),
	testPappySubcoda :: Result TestPappyDerivs (String),
	testPappySubonset :: Result TestPappyDerivs (String),
	testPappySubglide :: Result TestPappyDerivs (Char),
	testPappySubdiphthong :: Result TestPappyDerivs (String),
	testPappySubvowel :: Result TestPappyDerivs (Char),
	testPappySubPlusRule21 :: Result TestPappyDerivs ([Char]),
	testPappySubinitial_pair :: Result TestPappyDerivs (String),
	testPappySubinitial :: Result TestPappyDerivs (String),
	testPappySubl :: Result TestPappyDerivs (Char),
	testPappySubm :: Result TestPappyDerivs (Char),
	testPappySubn :: Result TestPappyDerivs (Char),
	testPappySubr :: Result TestPappyDerivs (Char),
	testPappySubb :: Result TestPappyDerivs (Char),
	testPappySubd :: Result TestPappyDerivs (Char),
	testPappySubg :: Result TestPappyDerivs (Char),
	testPappySubv :: Result TestPappyDerivs (Char),
	testPappySubj :: Result TestPappyDerivs (Char),
	testPappySubz :: Result TestPappyDerivs (Char),
	testPappySubs :: Result TestPappyDerivs (Char),
	testPappySubc :: Result TestPappyDerivs (Char),
	testPappySubx :: Result TestPappyDerivs (Char),
	testPappySubk :: Result TestPappyDerivs (Char),
	testPappySubf :: Result TestPappyDerivs (Char),
	testPappySubp :: Result TestPappyDerivs (Char),
	testPappySubt :: Result TestPappyDerivs (Char),
	testPappySubdigit :: Result TestPappyDerivs (Char),
	testPappySubpost_word :: Result TestPappyDerivs (String),
	testPappySubPlusRule22 :: Result TestPappyDerivs ([Char]),
	testPappySubPlusRule23 :: Result TestPappyDerivs ([ String ]),
	testPappySubStarRule236 :: Result TestPappyDerivs ([Char]),
	testPappySubStarRule237 :: Result TestPappyDerivs ([Char])}

data TestPappyDerivs6 = TestPappyDerivs6 {
	testPappySubA :: Result TestPappyDerivs (String),
	testPappySubBAI :: Result TestPappyDerivs (String),
	testPappySubBAhE :: Result TestPappyDerivs (String),
	testPappySubBEhO :: Result TestPappyDerivs (String),
	testPappySubBIhE :: Result TestPappyDerivs (String),
	testPappySubBIhI :: Result TestPappyDerivs (String),
	testPappySubBU :: Result TestPappyDerivs (String),
	testPappySubBY :: Result TestPappyDerivs (String),
	testPappySubCAhA :: Result TestPappyDerivs (String),
	testPappySubCAI :: Result TestPappyDerivs (String),
	testPappySubCEhE :: Result TestPappyDerivs (String),
	testPappySubCO :: Result TestPappyDerivs (String),
	testPappySubCOI :: Result TestPappyDerivs (String),
	testPappySubCUhE :: Result TestPappyDerivs (String),
	testPappySubDAhO :: Result TestPappyDerivs (String),
	testPappySubDOhU :: Result TestPappyDerivs (String),
	testPappySubFA :: Result TestPappyDerivs (String),
	testPappySubFAhA :: Result TestPappyDerivs (String),
	testPappySubFAhO :: Result TestPappyDerivs (String),
	testPappySubFEhE :: Result TestPappyDerivs (String),
	testPappySubFEhU :: Result TestPappyDerivs (String),
	testPappySubFIhO :: Result TestPappyDerivs (String),
	testPappySubFUhA :: Result TestPappyDerivs (String),
	testPappySubFUhE :: Result TestPappyDerivs (String),
	testPappySubFUhO :: Result TestPappyDerivs (String),
	testPappySubGA :: Result TestPappyDerivs (String),
	testPappySubGAhO :: Result TestPappyDerivs (String),
	testPappySubGEhU :: Result TestPappyDerivs (String),
	testPappySubGIhA :: Result TestPappyDerivs (String),
	testPappySubGOI :: Result TestPappyDerivs (String),
	testPappySubGOhA :: Result TestPappyDerivs (String),
	testPappySubGUhA :: Result TestPappyDerivs (String),
	testPappySubJA :: Result TestPappyDerivs (String)}

data TestPappyDerivs7 = TestPappyDerivs7 {
	testPappySubJOhI :: Result TestPappyDerivs (String),
	testPappySubJOI :: Result TestPappyDerivs (String),
	testPappySubKEhE :: Result TestPappyDerivs (String),
	testPappySubKOhA :: Result TestPappyDerivs (String),
	testPappySubKU :: Result TestPappyDerivs (String),
	testPappySubKUhE :: Result TestPappyDerivs (String),
	testPappySubKUhO :: Result TestPappyDerivs (String),
	testPappySubLA :: Result TestPappyDerivs (String),
	testPappySubLAU :: Result TestPappyDerivs (String),
	testPappySubLAhE :: Result TestPappyDerivs (String),
	testPappySubLE :: Result TestPappyDerivs (String),
	testPappySubLEhU :: Result TestPappyDerivs (String),
	testPappySubLI :: Result TestPappyDerivs (String),
	testPappySubLIhU :: Result TestPappyDerivs (String),
	testPappySubLOhO :: Result TestPappyDerivs (String),
	testPappySubLOhU :: Result TestPappyDerivs (String),
	testPappySubLUhU :: Result TestPappyDerivs (String),
	testPappySubMAhO :: Result TestPappyDerivs (String),
	testPappySubMAI :: Result TestPappyDerivs (String),
	testPappySubMEhU :: Result TestPappyDerivs (String),
	testPappySubMOhE :: Result TestPappyDerivs (String),
	testPappySubMOhI :: Result TestPappyDerivs (String),
	testPappySubMOI :: Result TestPappyDerivs (String),
	testPappySubNA :: Result TestPappyDerivs (String),
	testPappySubNAhE :: Result TestPappyDerivs (String),
	testPappySubNAhU :: Result TestPappyDerivs (String),
	testPappySubNIhE :: Result TestPappyDerivs (String),
	testPappySubNIhO :: Result TestPappyDerivs (String),
	testPappySubNOI :: Result TestPappyDerivs (String),
	testPappySubNU :: Result TestPappyDerivs (String),
	testPappySubNUhA :: Result TestPappyDerivs (String),
	testPappySubNUhI :: Result TestPappyDerivs (String),
	testPappySubNUhU :: Result TestPappyDerivs (String)}

data TestPappyDerivs8 = TestPappyDerivs8 {
	testPappySubPA :: Result TestPappyDerivs (String),
	testPappySubPEhE :: Result TestPappyDerivs (String),
	testPappySubPEhO :: Result TestPappyDerivs (String),
	testPappySubPU :: Result TestPappyDerivs (String),
	testPappySubRAhO :: Result TestPappyDerivs (String),
	testPappySubROI :: Result TestPappyDerivs (String),
	testPappySubSE :: Result TestPappyDerivs (String),
	testPappySubSEI :: Result TestPappyDerivs (String),
	testPappySubSEhU :: Result TestPappyDerivs (String),
	testPappySubSI :: Result TestPappyDerivs (String),
	testPappySubSU :: Result TestPappyDerivs (String),
	testPappySubTAhE :: Result TestPappyDerivs (String),
	testPappySubTEhU :: Result TestPappyDerivs (String),
	testPappySubTO :: Result TestPappyDerivs (String),
	testPappySubTUhE :: Result TestPappyDerivs (String),
	testPappySubTUhU :: Result TestPappyDerivs (String),
	testPappySubUI :: Result TestPappyDerivs (String),
	testPappySubVA :: Result TestPappyDerivs (String),
	testPappySubVEhO :: Result TestPappyDerivs (String),
	testPappySubVUhU :: Result TestPappyDerivs (String),
	testPappySubVEhA :: Result TestPappyDerivs (String),
	testPappySubVIhA :: Result TestPappyDerivs (String),
	testPappySubVUhO :: Result TestPappyDerivs (String),
	testPappySubPlusRule24 :: Result TestPappyDerivs ([Char]),
	testPappySubZAhO :: Result TestPappyDerivs (String),
	testPappySubZEhA :: Result TestPappyDerivs (String),
	testPappySubZI :: Result TestPappyDerivs (String),
	testPappySubZIhE :: Result TestPappyDerivs (String),
	testPappySubZOI :: Result TestPappyDerivs (String),
	testPappySubZOhU :: Result TestPappyDerivs (String),
	testPappySubdummyTail :: Result TestPappyDerivs ((() -> ())),
	testPappySubdummy :: Result TestPappyDerivs (())}

testPappyStarRule0 = testPappySubStarRule0 . testPappySub0
testPappytext = testPappySubtext . testPappySub0
testPappyStarRule3 = testPappySubStarRule3 . testPappySub0
testPappytext_1 = testPappySubtext_1 . testPappySub0
testPappyparagraphs = testPappySubparagraphs . testPappySub0
testPappyPlusRule2 = testPappySubPlusRule2 . testPappySub0
testPappyStarRule8 = testPappySubStarRule8 . testPappySub0
testPappyStarRule9 = testPappySubStarRule9 . testPappySub0
testPappystatement = testPappySubstatement . testPappySub0
testPappyStarRule11 = testPappySubStarRule11 . testPappySub0
testPappystatement_2 = testPappySubstatement_2 . testPappySub0
testPappyfragment = testPappySubfragment . testPappySub0
testPappysentence = testPappySubsentence . testPappySub0
testPappyStarRule21 = testPappySubStarRule21 . testPappySub0
testPappyStarRule23 = testPappySubStarRule23 . testPappySub0
testPappysubsentence = testPappySubsubsentence . testPappySub0
testPappybridi_tail = testPappySubbridi_tail . testPappySub0
testPappyStarRule26 = testPappySubStarRule26 . testPappySub0
testPappybridi_tail_start = testPappySubbridi_tail_start . testPappySub0
testPappyStarRule27 = testPappySubStarRule27 . testPappySub0
testPappybridi_tail_2 = testPappySubbridi_tail_2 . testPappySub0
testPappygek_sentence = testPappySubgek_sentence . testPappySub0
testPappyPlusRule3 = testPappySubPlusRule3 . testPappySub0
testPappyStarRule34 = testPappySubStarRule34 . testPappySub0
testPappyStarRule35 = testPappySubStarRule35 . testPappySub0
testPappyStarRule37 = testPappySubStarRule37 . testPappySub0
testPappyStarRule38 = testPappySubStarRule38 . testPappySub0
testPappyStarRule40 = testPappySubStarRule40 . testPappySub0
testPappyStarRule41 = testPappySubStarRule41 . testPappySub0
testPappyStarRule42 = testPappySubStarRule42 . testPappySub0
testPappyterm_1 = testPappySubterm_1 . testPappySub0
testPappyStarRule46 = testPappySubStarRule46 . testPappySub0
testPappyterm_start = testPappySubterm_start . testPappySub0
testPappyterms_gik_terms = testPappySubterms_gik_terms . testPappySub1
testPappysumti = testPappySubsumti . testPappySub1
testPappyStarRule55 = testPappySubStarRule55 . testPappySub1
testPappysumti_3 = testPappySubsumti_3 . testPappySub1
testPappysumti_4 = testPappySubsumti_4 . testPappySub1
testPappysumti_6 = testPappySubsumti_6 . testPappySub1
testPappyLAhE_NAhE = testPappySubLAhE_NAhE . testPappySub1
testPappyStarRule73 = testPappySubStarRule73 . testPappySub1
testPappyStarRule75 = testPappySubStarRule75 . testPappySub1
testPappyStarRule76 = testPappySubStarRule76 . testPappySub1
testPappyrelative_clause_1 = testPappySubrelative_clause_1 . testPappySub1
testPappyselbri = testPappySubselbri . testPappySub1
testPappyselbri_2 = testPappySubselbri_2 . testPappySub1
testPappyPlusRule5 = testPappySubPlusRule5 . testPappySub1
testPappyStarRule83 = testPappySubStarRule83 . testPappySub1
testPappyselbri_5 = testPappySubselbri_5 . testPappySub1
testPappyselbri_6 = testPappySubselbri_6 . testPappySub1
testPappyStarRule89 = testPappySubStarRule89 . testPappySub1
testPappyStarRule104 = testPappySubStarRule104 . testPappySub1
testPappytanru_unit_2 = testPappySubtanru_unit_2 . testPappySub1
testPappyStarRule107 = testPappySubStarRule107 . testPappySub1
testPappylinkargs_1 = testPappySublinkargs_1 . testPappySub1
testPappyStarRule110 = testPappySubStarRule110 . testPappySub1
testPappyStarRule111 = testPappySubStarRule111 . testPappySub1
testPappylinks_1 = testPappySublinks_1 . testPappySub1
testPappyStarRule113 = testPappySubStarRule113 . testPappySub1
testPappyquantifier = testPappySubquantifier . testPappySub1
testPappyStarRule117 = testPappySubStarRule117 . testPappySub1
testPappyStarRule118 = testPappySubStarRule118 . testPappySub1
testPappymex_0 = testPappySubmex_0 . testPappySub1
testPappyStarRule119 = testPappySubStarRule119 . testPappySub1
testPappymex_start = testPappySubmex_start . testPappySub1
testPappymex_1 = testPappySubmex_1 . testPappySub1
testPappymex_2 = testPappySubmex_2 . testPappySub2
testPappyrp_expression_tail = testPappySubrp_expression_tail . testPappySub2
testPappyStarRule124 = testPappySubStarRule124 . testPappySub2
testPappyStarRule125 = testPappySubStarRule125 . testPappySub2
testPappyStarRule128 = testPappySubStarRule128 . testPappySub2
testPappyoperator_start = testPappySuboperator_start . testPappySub2
testPappyoperator_1 = testPappySuboperator_1 . testPappySub2
testPappyoperator_2 = testPappySuboperator_2 . testPappySub2
testPappymex_operator = testPappySubmex_operator . testPappySub2
testPappyStarRule139 = testPappySubStarRule139 . testPappySub2
testPappyoperand_0 = testPappySuboperand_0 . testPappySub2
testPappyStarRule142 = testPappySubStarRule142 . testPappySub2
testPappyoperand_start = testPappySuboperand_start . testPappySub2
testPappyStarRule143 = testPappySubStarRule143 . testPappySub2
testPappyoperand_2 = testPappySuboperand_2 . testPappySub2
testPappyPlusRule7 = testPappySubPlusRule7 . testPappySub2
testPappyoperand_3 = testPappySuboperand_3 . testPappySub2
testPappyStarRule154 = testPappySubStarRule154 . testPappySub2
testPappylerfu_word = testPappySublerfu_word . testPappySub2
testPappyek = testPappySubek . testPappySub2
testPappyStarRule155 = testPappySubStarRule155 . testPappySub2
testPappygihek_1 = testPappySubgihek_1 . testPappySub2
testPappyStarRule156 = testPappySubStarRule156 . testPappySub2
testPappyjek = testPappySubjek . testPappySub2
testPappyjoik = testPappySubjoik . testPappySub2
testPappyinterval = testPappySubinterval . testPappySub2
testPappyStarRule157 = testPappySubStarRule157 . testPappySub2
testPappyStarRule160 = testPappySubStarRule160 . testPappySub2
testPappygek = testPappySubgek . testPappySub2
testPappyguhek = testPappySubguhek . testPappySub2
testPappygik = testPappySubgik . testPappySub2
testPappyStarRule168 = testPappySubStarRule168 . testPappySub2
testPappyStarRule169 = testPappySubStarRule169 . testPappySub2
testPappytense_modal = testPappySubtense_modal . testPappySub3
testPappysimple_tense_modal = testPappySubsimple_tense_modal . testPappySub3
testPappyPlusRule8 = testPappySubPlusRule8 . testPappySub3
testPappyStarRule177 = testPappySubStarRule177 . testPappySub3
testPappyStarRule178 = testPappySubStarRule178 . testPappySub3
testPappyPlusRule9 = testPappySubPlusRule9 . testPappySub3
testPappytime = testPappySubtime . testPappySub3
testPappyzeha_pu = testPappySubzeha_pu . testPappySub3
testPappytime_offset = testPappySubtime_offset . testPappySub3
testPappyPlusRule10 = testPappySubPlusRule10 . testPappySub3
testPappyStarRule181 = testPappySubStarRule181 . testPappySub3
testPappyspace = testPappySubspace . testPappySub3
testPappyspace_offset = testPappySubspace_offset . testPappySub3
testPappyspace_interval = testPappySubspace_interval . testPappySub3
testPappyVEhA_VIhA = testPappySubVEhA_VIhA . testPappySub3
testPappyPlusRule11 = testPappySubPlusRule11 . testPappySub3
testPappyinterval_property = testPappySubinterval_property . testPappySub3
testPappyPlusRule12 = testPappySubPlusRule12 . testPappySub3
testPappyStarRule188 = testPappySubStarRule188 . testPappySub3
testPappyPlusRule13 = testPappySubPlusRule13 . testPappySub3
testPappyStarRule189 = testPappySubStarRule189 . testPappySub3
testPappyvocative = testPappySubvocative . testPappySub3
testPappycoi_nai = testPappySubcoi_nai . testPappySub3
testPappyPlusRule14 = testPappySubPlusRule14 . testPappySub3
testPappyindicator = testPappySubindicator . testPappySub3
testPappyStarRule190 = testPappySubStarRule190 . testPappySub3
testPappyStarRule191 = testPappySubStarRule191 . testPappySub3
testPappyPlusRule15 = testPappySubPlusRule15 . testPappySub3
testPappyPlusRule16 = testPappySubPlusRule16 . testPappySub3
testPappypre_zei_bu = testPappySubpre_zei_bu . testPappySub3
testPappyStarRule192 = testPappySubStarRule192 . testPappySub3
testPappyStarRule193 = testPappySubStarRule193 . testPappySub3
testPappyany_word_SA_handling = testPappySubany_word_SA_handling . testPappySub3
testPappyStarRule194 = testPappySubStarRule194 . testPappySub4
testPappyPlusRule17 = testPappySubPlusRule17 . testPappySub4
testPappysi_clause_single = testPappySubsi_clause_single . testPappySub4
testPappyerasable_clause = testPappySuberasable_clause . testPappySub4
testPappyBRIVLA_pre = testPappySubBRIVLA_pre . testPappySub4
testPappyPlusRule18 = testPappySubPlusRule18 . testPappySub4
testPappyStarRule195 = testPappySubStarRule195 . testPappySub4
testPappyStarRule196 = testPappySubStarRule196 . testPappySub4
testPappyStarRule198 = testPappySubStarRule198 . testPappySub4
testPappyPlusRule19 = testPappySubPlusRule19 . testPappySub4
testPappycmene = testPappySubcmene . testPappySub4
testPappyStarRule200 = testPappySubStarRule200 . testPappySub4
testPappycmavo = testPappySubcmavo . testPappySub4
testPappyStarRule202 = testPappySubStarRule202 . testPappySub4
testPappyStarRule203 = testPappySubStarRule203 . testPappySub4
testPappystressed_extended_rafsi = testPappySubstressed_extended_rafsi . testPappySub4
testPappyextended_rafsi = testPappySubextended_rafsi . testPappySub4
testPappyStarRule205 = testPappySubStarRule205 . testPappySub4
testPappyStarRule206 = testPappySubStarRule206 . testPappySub4
testPappybrivla_head = testPappySubbrivla_head . testPappySub4
testPappyStarRule207 = testPappySubStarRule207 . testPappySub4
testPappyCVV_final_rafsi = testPappySubCVV_final_rafsi . testPappySub4
testPappyshort_final_rafsi = testPappySubshort_final_rafsi . testPappySub4
testPappystressed_y_rafsi = testPappySubstressed_y_rafsi . testPappySub4
testPappystressed_y_less_rafsi = testPappySubstressed_y_less_rafsi . testPappySub4
testPappystressed_long_rafsi = testPappySubstressed_long_rafsi . testPappySub4
testPappyy_rafsi = testPappySuby_rafsi . testPappySub4
testPappyy_less_rafsi = testPappySuby_less_rafsi . testPappySub4
testPappyr_hyphen = testPappySubr_hyphen . testPappySub4
testPappyfinal_syllable = testPappySubfinal_syllable . testPappySub4
testPappystressed_syllable = testPappySubstressed_syllable . testPappySub4
testPappystressed_vowel = testPappySubstressed_vowel . testPappySub4
testPappyunstressed_syllable = testPappySubunstressed_syllable . testPappySub4
testPappyStarRule208 = testPappySubStarRule208 . testPappySub5
testPappyconsonantal_syllable = testPappySubconsonantal_syllable . testPappySub5
testPappycoda = testPappySubcoda . testPappySub5
testPappyonset = testPappySubonset . testPappySub5
testPappyglide = testPappySubglide . testPappySub5
testPappydiphthong = testPappySubdiphthong . testPappySub5
testPappyvowel = testPappySubvowel . testPappySub5
testPappyPlusRule21 = testPappySubPlusRule21 . testPappySub5
testPappyinitial_pair = testPappySubinitial_pair . testPappySub5
testPappyinitial = testPappySubinitial . testPappySub5
testPappyl = testPappySubl . testPappySub5
testPappym = testPappySubm . testPappySub5
testPappyn = testPappySubn . testPappySub5
testPappyr = testPappySubr . testPappySub5
testPappyb = testPappySubb . testPappySub5
testPappyd = testPappySubd . testPappySub5
testPappyg = testPappySubg . testPappySub5
testPappyv = testPappySubv . testPappySub5
testPappyj = testPappySubj . testPappySub5
testPappyz = testPappySubz . testPappySub5
testPappys = testPappySubs . testPappySub5
testPappyc = testPappySubc . testPappySub5
testPappyx = testPappySubx . testPappySub5
testPappyk = testPappySubk . testPappySub5
testPappyf = testPappySubf . testPappySub5
testPappyp = testPappySubp . testPappySub5
testPappyt = testPappySubt . testPappySub5
testPappydigit = testPappySubdigit . testPappySub5
testPappypost_word = testPappySubpost_word . testPappySub5
testPappyPlusRule22 = testPappySubPlusRule22 . testPappySub5
testPappyPlusRule23 = testPappySubPlusRule23 . testPappySub5
testPappyStarRule236 = testPappySubStarRule236 . testPappySub5
testPappyStarRule237 = testPappySubStarRule237 . testPappySub5
testPappyA = testPappySubA . testPappySub6
testPappyBAI = testPappySubBAI . testPappySub6
testPappyBAhE = testPappySubBAhE . testPappySub6
testPappyBEhO = testPappySubBEhO . testPappySub6
testPappyBIhE = testPappySubBIhE . testPappySub6
testPappyBIhI = testPappySubBIhI . testPappySub6
testPappyBU = testPappySubBU . testPappySub6
testPappyBY = testPappySubBY . testPappySub6
testPappyCAhA = testPappySubCAhA . testPappySub6
testPappyCAI = testPappySubCAI . testPappySub6
testPappyCEhE = testPappySubCEhE . testPappySub6
testPappyCO = testPappySubCO . testPappySub6
testPappyCOI = testPappySubCOI . testPappySub6
testPappyCUhE = testPappySubCUhE . testPappySub6
testPappyDAhO = testPappySubDAhO . testPappySub6
testPappyDOhU = testPappySubDOhU . testPappySub6
testPappyFA = testPappySubFA . testPappySub6
testPappyFAhA = testPappySubFAhA . testPappySub6
testPappyFAhO = testPappySubFAhO . testPappySub6
testPappyFEhE = testPappySubFEhE . testPappySub6
testPappyFEhU = testPappySubFEhU . testPappySub6
testPappyFIhO = testPappySubFIhO . testPappySub6
testPappyFUhA = testPappySubFUhA . testPappySub6
testPappyFUhE = testPappySubFUhE . testPappySub6
testPappyFUhO = testPappySubFUhO . testPappySub6
testPappyGA = testPappySubGA . testPappySub6
testPappyGAhO = testPappySubGAhO . testPappySub6
testPappyGEhU = testPappySubGEhU . testPappySub6
testPappyGIhA = testPappySubGIhA . testPappySub6
testPappyGOI = testPappySubGOI . testPappySub6
testPappyGOhA = testPappySubGOhA . testPappySub6
testPappyGUhA = testPappySubGUhA . testPappySub6
testPappyJA = testPappySubJA . testPappySub6
testPappyJOhI = testPappySubJOhI . testPappySub7
testPappyJOI = testPappySubJOI . testPappySub7
testPappyKEhE = testPappySubKEhE . testPappySub7
testPappyKOhA = testPappySubKOhA . testPappySub7
testPappyKU = testPappySubKU . testPappySub7
testPappyKUhE = testPappySubKUhE . testPappySub7
testPappyKUhO = testPappySubKUhO . testPappySub7
testPappyLA = testPappySubLA . testPappySub7
testPappyLAU = testPappySubLAU . testPappySub7
testPappyLAhE = testPappySubLAhE . testPappySub7
testPappyLE = testPappySubLE . testPappySub7
testPappyLEhU = testPappySubLEhU . testPappySub7
testPappyLI = testPappySubLI . testPappySub7
testPappyLIhU = testPappySubLIhU . testPappySub7
testPappyLOhO = testPappySubLOhO . testPappySub7
testPappyLOhU = testPappySubLOhU . testPappySub7
testPappyLUhU = testPappySubLUhU . testPappySub7
testPappyMAhO = testPappySubMAhO . testPappySub7
testPappyMAI = testPappySubMAI . testPappySub7
testPappyMEhU = testPappySubMEhU . testPappySub7
testPappyMOhE = testPappySubMOhE . testPappySub7
testPappyMOhI = testPappySubMOhI . testPappySub7
testPappyMOI = testPappySubMOI . testPappySub7
testPappyNA = testPappySubNA . testPappySub7
testPappyNAhE = testPappySubNAhE . testPappySub7
testPappyNAhU = testPappySubNAhU . testPappySub7
testPappyNIhE = testPappySubNIhE . testPappySub7
testPappyNIhO = testPappySubNIhO . testPappySub7
testPappyNOI = testPappySubNOI . testPappySub7
testPappyNU = testPappySubNU . testPappySub7
testPappyNUhA = testPappySubNUhA . testPappySub7
testPappyNUhI = testPappySubNUhI . testPappySub7
testPappyNUhU = testPappySubNUhU . testPappySub7
testPappyPA = testPappySubPA . testPappySub8
testPappyPEhE = testPappySubPEhE . testPappySub8
testPappyPEhO = testPappySubPEhO . testPappySub8
testPappyPU = testPappySubPU . testPappySub8
testPappyRAhO = testPappySubRAhO . testPappySub8
testPappyROI = testPappySubROI . testPappySub8
testPappySE = testPappySubSE . testPappySub8
testPappySEI = testPappySubSEI . testPappySub8
testPappySEhU = testPappySubSEhU . testPappySub8
testPappySI = testPappySubSI . testPappySub8
testPappySU = testPappySubSU . testPappySub8
testPappyTAhE = testPappySubTAhE . testPappySub8
testPappyTEhU = testPappySubTEhU . testPappySub8
testPappyTO = testPappySubTO . testPappySub8
testPappyTUhE = testPappySubTUhE . testPappySub8
testPappyTUhU = testPappySubTUhU . testPappySub8
testPappyUI = testPappySubUI . testPappySub8
testPappyVA = testPappySubVA . testPappySub8
testPappyVEhO = testPappySubVEhO . testPappySub8
testPappyVUhU = testPappySubVUhU . testPappySub8
testPappyVEhA = testPappySubVEhA . testPappySub8
testPappyVIhA = testPappySubVIhA . testPappySub8
testPappyVUhO = testPappySubVUhO . testPappySub8
testPappyPlusRule24 = testPappySubPlusRule24 . testPappySub8
testPappyZAhO = testPappySubZAhO . testPappySub8
testPappyZEhA = testPappySubZEhA . testPappySub8
testPappyZI = testPappySubZI . testPappySub8
testPappyZIhE = testPappySubZIhE . testPappySub8
testPappyZOI = testPappySubZOI . testPappySub8
testPappyZOhU = testPappySubZOhU . testPappySub8
testPappydummyTail = testPappySubdummyTail . testPappySub8
testPappydummy = testPappySubdummy . testPappySub8

testPappyParse :: String -> String -> TestPappyDerivs
testPappyParse name text = testPappyDerivs (Pos name 1 1) text

testPappyDerivs :: Pos -> String -> TestPappyDerivs
testPappyDerivs pos text = dvs where
  dvs = TestPappyDerivs
    (testPappyDerivs0 dvs)
    (testPappyDerivs1 dvs)
    (testPappyDerivs2 dvs)
    (testPappyDerivs3 dvs)
    (testPappyDerivs4 dvs)
    (testPappyDerivs5 dvs)
    (testPappyDerivs6 dvs)
    (testPappyDerivs7 dvs)
    (testPappyDerivs8 dvs)
    chr pos
  chr = case text of
    [] -> NoParse (eofError dvs)
    (c:cs) -> Parsed c (testPappyDerivs (nextPos pos c) cs) (nullError dvs)

testPappyDerivs0 dvs = TestPappyDerivs0
	(testPappyParseStarRule0 dvs)
	(testPappyParsetext dvs)
	(testPappyParseStarRule3 dvs)
	(testPappyParsetext_1 dvs)
	(testPappyParseparagraphs dvs)
	(testPappyParsePlusRule2 dvs)
	(testPappyParseStarRule8 dvs)
	(testPappyParseStarRule9 dvs)
	(testPappyParsestatement dvs)
	(testPappyParseStarRule11 dvs)
	(testPappyParsestatement_2 dvs)
	(testPappyParsefragment dvs)
	(testPappyParsesentence dvs)
	(testPappyParseStarRule21 dvs)
	(testPappyParseStarRule23 dvs)
	(testPappyParsesubsentence dvs)
	(testPappyParsebridi_tail dvs)
	(testPappyParseStarRule26 dvs)
	(testPappyParsebridi_tail_start dvs)
	(testPappyParseStarRule27 dvs)
	(testPappyParsebridi_tail_2 dvs)
	(testPappyParsegek_sentence dvs)
	(testPappyParsePlusRule3 dvs)
	(testPappyParseStarRule34 dvs)
	(testPappyParseStarRule35 dvs)
	(testPappyParseStarRule37 dvs)
	(testPappyParseStarRule38 dvs)
	(testPappyParseStarRule40 dvs)
	(testPappyParseStarRule41 dvs)
	(testPappyParseStarRule42 dvs)
	(testPappyParseterm_1 dvs)
	(testPappyParseStarRule46 dvs)
	(testPappyParseterm_start dvs)

testPappyDerivs1 dvs = TestPappyDerivs1
	(testPappyParseterms_gik_terms dvs)
	(testPappyParsesumti dvs)
	(testPappyParseStarRule55 dvs)
	(testPappyParsesumti_3 dvs)
	(testPappyParsesumti_4 dvs)
	(testPappyParsesumti_6 dvs)
	(testPappyParseLAhE_NAhE dvs)
	(testPappyParseStarRule73 dvs)
	(testPappyParseStarRule75 dvs)
	(testPappyParseStarRule76 dvs)
	(testPappyParserelative_clause_1 dvs)
	(testPappyParseselbri dvs)
	(testPappyParseselbri_2 dvs)
	(testPappyParsePlusRule5 dvs)
	(testPappyParseStarRule83 dvs)
	(testPappyParseselbri_5 dvs)
	(testPappyParseselbri_6 dvs)
	(testPappyParseStarRule89 dvs)
	(testPappyParseStarRule104 dvs)
	(testPappyParsetanru_unit_2 dvs)
	(testPappyParseStarRule107 dvs)
	(testPappyParselinkargs_1 dvs)
	(testPappyParseStarRule110 dvs)
	(testPappyParseStarRule111 dvs)
	(testPappyParselinks_1 dvs)
	(testPappyParseStarRule113 dvs)
	(testPappyParsequantifier dvs)
	(testPappyParseStarRule117 dvs)
	(testPappyParseStarRule118 dvs)
	(testPappyParsemex_0 dvs)
	(testPappyParseStarRule119 dvs)
	(testPappyParsemex_start dvs)
	(testPappyParsemex_1 dvs)

testPappyDerivs2 dvs = TestPappyDerivs2
	(testPappyParsemex_2 dvs)
	(testPappyParserp_expression_tail dvs)
	(testPappyParseStarRule124 dvs)
	(testPappyParseStarRule125 dvs)
	(testPappyParseStarRule128 dvs)
	(testPappyParseoperator_start dvs)
	(testPappyParseoperator_1 dvs)
	(testPappyParseoperator_2 dvs)
	(testPappyParsemex_operator dvs)
	(testPappyParseStarRule139 dvs)
	(testPappyParseoperand_0 dvs)
	(testPappyParseStarRule142 dvs)
	(testPappyParseoperand_start dvs)
	(testPappyParseStarRule143 dvs)
	(testPappyParseoperand_2 dvs)
	(testPappyParsePlusRule7 dvs)
	(testPappyParseoperand_3 dvs)
	(testPappyParseStarRule154 dvs)
	(testPappyParselerfu_word dvs)
	(testPappyParseek dvs)
	(testPappyParseStarRule155 dvs)
	(testPappyParsegihek_1 dvs)
	(testPappyParseStarRule156 dvs)
	(testPappyParsejek dvs)
	(testPappyParsejoik dvs)
	(testPappyParseinterval dvs)
	(testPappyParseStarRule157 dvs)
	(testPappyParseStarRule160 dvs)
	(testPappyParsegek dvs)
	(testPappyParseguhek dvs)
	(testPappyParsegik dvs)
	(testPappyParseStarRule168 dvs)
	(testPappyParseStarRule169 dvs)

testPappyDerivs3 dvs = TestPappyDerivs3
	(testPappyParsetense_modal dvs)
	(testPappyParsesimple_tense_modal dvs)
	(testPappyParsePlusRule8 dvs)
	(testPappyParseStarRule177 dvs)
	(testPappyParseStarRule178 dvs)
	(testPappyParsePlusRule9 dvs)
	(testPappyParsetime dvs)
	(testPappyParsezeha_pu dvs)
	(testPappyParsetime_offset dvs)
	(testPappyParsePlusRule10 dvs)
	(testPappyParseStarRule181 dvs)
	(testPappyParsespace dvs)
	(testPappyParsespace_offset dvs)
	(testPappyParsespace_interval dvs)
	(testPappyParseVEhA_VIhA dvs)
	(testPappyParsePlusRule11 dvs)
	(testPappyParseinterval_property dvs)
	(testPappyParsePlusRule12 dvs)
	(testPappyParseStarRule188 dvs)
	(testPappyParsePlusRule13 dvs)
	(testPappyParseStarRule189 dvs)
	(testPappyParsevocative dvs)
	(testPappyParsecoi_nai dvs)
	(testPappyParsePlusRule14 dvs)
	(testPappyParseindicator dvs)
	(testPappyParseStarRule190 dvs)
	(testPappyParseStarRule191 dvs)
	(testPappyParsePlusRule15 dvs)
	(testPappyParsePlusRule16 dvs)
	(testPappyParsepre_zei_bu dvs)
	(testPappyParseStarRule192 dvs)
	(testPappyParseStarRule193 dvs)
	(testPappyParseany_word_SA_handling dvs)

testPappyDerivs4 dvs = TestPappyDerivs4
	(testPappyParseStarRule194 dvs)
	(testPappyParsePlusRule17 dvs)
	(testPappyParsesi_clause_single dvs)
	(testPappyParseerasable_clause dvs)
	(testPappyParseBRIVLA_pre dvs)
	(testPappyParsePlusRule18 dvs)
	(testPappyParseStarRule195 dvs)
	(testPappyParseStarRule196 dvs)
	(testPappyParseStarRule198 dvs)
	(testPappyParsePlusRule19 dvs)
	(testPappyParsecmene dvs)
	(testPappyParseStarRule200 dvs)
	(testPappyParsecmavo dvs)
	(testPappyParseStarRule202 dvs)
	(testPappyParseStarRule203 dvs)
	(testPappyParsestressed_extended_rafsi dvs)
	(testPappyParseextended_rafsi dvs)
	(testPappyParseStarRule205 dvs)
	(testPappyParseStarRule206 dvs)
	(testPappyParsebrivla_head dvs)
	(testPappyParseStarRule207 dvs)
	(testPappyParseCVV_final_rafsi dvs)
	(testPappyParseshort_final_rafsi dvs)
	(testPappyParsestressed_y_rafsi dvs)
	(testPappyParsestressed_y_less_rafsi dvs)
	(testPappyParsestressed_long_rafsi dvs)
	(testPappyParsey_rafsi dvs)
	(testPappyParsey_less_rafsi dvs)
	(testPappyParser_hyphen dvs)
	(testPappyParsefinal_syllable dvs)
	(testPappyParsestressed_syllable dvs)
	(testPappyParsestressed_vowel dvs)
	(testPappyParseunstressed_syllable dvs)

testPappyDerivs5 dvs = TestPappyDerivs5
	(testPappyParseStarRule208 dvs)
	(testPappyParseconsonantal_syllable dvs)
	(testPappyParsecoda dvs)
	(testPappyParseonset dvs)
	(testPappyParseglide dvs)
	(testPappyParsediphthong dvs)
	(testPappyParsevowel dvs)
	(testPappyParsePlusRule21 dvs)
	(testPappyParseinitial_pair dvs)
	(testPappyParseinitial dvs)
	(testPappyParsel dvs)
	(testPappyParsem dvs)
	(testPappyParsen dvs)
	(testPappyParser dvs)
	(testPappyParseb dvs)
	(testPappyParsed dvs)
	(testPappyParseg dvs)
	(testPappyParsev dvs)
	(testPappyParsej dvs)
	(testPappyParsez dvs)
	(testPappyParses dvs)
	(testPappyParsec dvs)
	(testPappyParsex dvs)
	(testPappyParsek dvs)
	(testPappyParsef dvs)
	(testPappyParsep dvs)
	(testPappyParset dvs)
	(testPappyParsedigit dvs)
	(testPappyParsepost_word dvs)
	(testPappyParsePlusRule22 dvs)
	(testPappyParsePlusRule23 dvs)
	(testPappyParseStarRule236 dvs)
	(testPappyParseStarRule237 dvs)

testPappyDerivs6 dvs = TestPappyDerivs6
	(testPappyParseA dvs)
	(testPappyParseBAI dvs)
	(testPappyParseBAhE dvs)
	(testPappyParseBEhO dvs)
	(testPappyParseBIhE dvs)
	(testPappyParseBIhI dvs)
	(testPappyParseBU dvs)
	(testPappyParseBY dvs)
	(testPappyParseCAhA dvs)
	(testPappyParseCAI dvs)
	(testPappyParseCEhE dvs)
	(testPappyParseCO dvs)
	(testPappyParseCOI dvs)
	(testPappyParseCUhE dvs)
	(testPappyParseDAhO dvs)
	(testPappyParseDOhU dvs)
	(testPappyParseFA dvs)
	(testPappyParseFAhA dvs)
	(testPappyParseFAhO dvs)
	(testPappyParseFEhE dvs)
	(testPappyParseFEhU dvs)
	(testPappyParseFIhO dvs)
	(testPappyParseFUhA dvs)
	(testPappyParseFUhE dvs)
	(testPappyParseFUhO dvs)
	(testPappyParseGA dvs)
	(testPappyParseGAhO dvs)
	(testPappyParseGEhU dvs)
	(testPappyParseGIhA dvs)
	(testPappyParseGOI dvs)
	(testPappyParseGOhA dvs)
	(testPappyParseGUhA dvs)
	(testPappyParseJA dvs)

testPappyDerivs7 dvs = TestPappyDerivs7
	(testPappyParseJOhI dvs)
	(testPappyParseJOI dvs)
	(testPappyParseKEhE dvs)
	(testPappyParseKOhA dvs)
	(testPappyParseKU dvs)
	(testPappyParseKUhE dvs)
	(testPappyParseKUhO dvs)
	(testPappyParseLA dvs)
	(testPappyParseLAU dvs)
	(testPappyParseLAhE dvs)
	(testPappyParseLE dvs)
	(testPappyParseLEhU dvs)
	(testPappyParseLI dvs)
	(testPappyParseLIhU dvs)
	(testPappyParseLOhO dvs)
	(testPappyParseLOhU dvs)
	(testPappyParseLUhU dvs)
	(testPappyParseMAhO dvs)
	(testPappyParseMAI dvs)
	(testPappyParseMEhU dvs)
	(testPappyParseMOhE dvs)
	(testPappyParseMOhI dvs)
	(testPappyParseMOI dvs)
	(testPappyParseNA dvs)
	(testPappyParseNAhE dvs)
	(testPappyParseNAhU dvs)
	(testPappyParseNIhE dvs)
	(testPappyParseNIhO dvs)
	(testPappyParseNOI dvs)
	(testPappyParseNU dvs)
	(testPappyParseNUhA dvs)
	(testPappyParseNUhI dvs)
	(testPappyParseNUhU dvs)

testPappyDerivs8 dvs = TestPappyDerivs8
	(testPappyParsePA dvs)
	(testPappyParsePEhE dvs)
	(testPappyParsePEhO dvs)
	(testPappyParsePU dvs)
	(testPappyParseRAhO dvs)
	(testPappyParseROI dvs)
	(testPappyParseSE dvs)
	(testPappyParseSEI dvs)
	(testPappyParseSEhU dvs)
	(testPappyParseSI dvs)
	(testPappyParseSU dvs)
	(testPappyParseTAhE dvs)
	(testPappyParseTEhU dvs)
	(testPappyParseTO dvs)
	(testPappyParseTUhE dvs)
	(testPappyParseTUhU dvs)
	(testPappyParseUI dvs)
	(testPappyParseVA dvs)
	(testPappyParseVEhO dvs)
	(testPappyParseVUhU dvs)
	(testPappyParseVEhA dvs)
	(testPappyParseVIhA dvs)
	(testPappyParseVUhO dvs)
	(testPappyParsePlusRule24 dvs)
	(testPappyParseZAhO dvs)
	(testPappyParseZEhA dvs)
	(testPappyParseZI dvs)
	(testPappyParseZIhE dvs)
	(testPappyParseZOI dvs)
	(testPappyParseZOhU dvs)
	(testPappyParsedummyTail dvs)
	(testPappyParsedummy dvs)

testPappytest :: TestPappyDerivs -> Result TestPappyDerivs (Text)
testPappytest d =
  case testPappytext d of
    Parsed t d1 e1 ->
      case testPappyanyChar d1 of
        NoParse e3 ->
          Parsed ( t ) d1 (max e3 e1)
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule0 :: TestPappyDerivs -> Result TestPappyDerivs ([Clause])
testPappyParseStarRule0 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyNAI_clause d of
        Parsed v d3 e3 ->
          case testPappyStarRule0 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

testPappyParsetext :: TestPappyDerivs -> Result TestPappyDerivs (Text)
testPappyParsetext d =
  case pappyResult1 of
    Parsed _ d1 e1 ->
      case testPappyStarRule8 d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              case testPappyStarRule3 d5 of
                Parsed _ d7 e7 ->
                  case testPappyStarRule0 d7 of
                    Parsed n d9 e9 ->
                      case pappyResult11 of
                        Parsed tp2 d11 e11 ->
                          case pappyResult13 of
                            Parsed jj d13 e13 ->
                              case pappyResult15 of
                                Parsed t d15 e15 ->
                                  case pappyResult17 of
                                    Parsed f d17 e17 ->
                                      case pappyResult19 of
                                        Parsed _ d19 e19 ->
                                          Parsed ( if isSimpleText n tp2 jj t f then fromJust t else TopText n (fst tp2) (snd tp2) jj t f ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7,e5,e3,e1])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e15,e13,e11,e9,e7,e5,e3,e1])
                                      where
                                        pappyResult19 =
                                          case pappyResult21 of
                                            Parsed v21 d21 e21 -> Parsed (Just v21) d21 e21
                                            NoParse e21 -> Parsed (Nothing) d17 e21
                                          where
                                            pappyResult21 =
                                              case testPappyanyChar d17 of
                                                NoParse e23 ->
                                                  Parsed ( () ) d17 e23
                                                Parsed _ _ e23 -> NoParse e23
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7,e5,e3,e1])
                                  where
                                    pappyResult17 =
                                      case pappyResult19 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                      where
                                        pappyResult19 =
                                          case testPappyFAhO_clause d15 of
                                            Parsed f d21 e21 ->
                                              case testPappyStarRule192 d21 of
                                                Parsed _ d23 e23 ->
                                                  Parsed ( f ) d23 (max e23 e21)
                                                NoParse e23 -> NoParse (max e23 e21)
                                            NoParse e21 -> NoParse e21
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7,e5,e3,e1])
                              where
                                pappyResult15 =
                                  case testPappytext_1 d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7,e5,e3,e1])
                          where
                            pappyResult13 =
                              case pappyResult15 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                              where
                                pappyResult15 =
                                  case testPappytext_1 d11 of
                                    NoParse e17 ->
                                      case testPappyjoik_jek d11 of
                                        Parsed j d19 e19 ->
                                          Parsed ( j ) d19 (max e19 e17)
                                        NoParse e19 -> NoParse (max e19 e17)
                                    Parsed _ _ e17 -> NoParse e17
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed e d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed f d15 e15 ->
                                  Parsed ( (e, f) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                          where
                            pappyResult13 =
                              pappyAlt15_1 (ParseError (testPappyPos d9) []) where
                                pappyAlt15_1 e15 =
                                  case testPappyPlusRule12 d9 of
                                    Parsed c d17 e17 ->
                                      Parsed ( Left c ) d17 (max e17 e15)
                                    NoParse e17 -> pappyAlt15_2 (max e17 e15)
                                pappyAlt15_2 e15 =
                                  case pappyResult17 of
                                    Parsed i d17 e17 ->
                                      Parsed ( Right i ) d17 (max e17 e15)
                                    NoParse e17 -> pappyAlt15_3 (max e17 e15)
                                  where
                                    pappyResult17 =
                                      case testPappyindicators d9 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d9 e19
                                pappyAlt15_3 e15 = NoParse e15
                    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 pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  case testPappyPlusRule17 d3 of
                    Parsed _ d9 e9 ->
                      Parsed ( () ) d9 e9
                    NoParse e9 -> NoParse e9
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyspaces d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParseStarRule3 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule3 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappySI_clause d of
        Parsed v d3 e3 ->
          case testPappyStarRule3 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

testPappyParsetext_1 :: TestPappyDerivs -> Result TestPappyDerivs (Text)
testPappyParsetext_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyI_clause d of
        Parsed i d3 e3 ->
          case pappyResult5 of
            Parsed j d5 e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case pappyResult11 of
                        Parsed t d11 e11 ->
                          Parsed ( IText_1 i j b f t ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_2 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case testPappytext_1 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])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed s d11 e11 ->
                          case testPappyBO_clause d11 of
                            Parsed b d13 e13 ->
                              Parsed ( (s, b) ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
                      where
                        pappyResult11 =
                          case testPappystag d5 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d5 e13
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d3) []) where
                    pappyAlt9_1 e9 =
                      case testPappyjek d3 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappyjoik d3 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyPlusRule2 d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyStarRule8 d5 of
                Parsed _ d7 e7 ->
                  case pappyResult9 of
                    Parsed p d9 e9 ->
                      Parsed ( HeadNIhO n f p ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyparagraphs d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                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 =
      case testPappyparagraphs d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseparagraphs :: TestPappyDerivs -> Result TestPappyDerivs (Paragraphs)
testPappyParseparagraphs d =
  case pappyResult1 of
    Parsed p d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          Parsed ( maybe p (uncurry3 $ NIhO p) n ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPlusRule2 d1 of
                Parsed n d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyStarRule8 d9 of
                        Parsed _ d11 e11 ->
                          case testPappyparagraphs d11 of
                            Parsed p d13 e13 ->
                              Parsed ( (n, f, p) ) d13 (maximum [e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed s d3 e3 ->
          case testPappyStarRule9 d3 of
            Parsed i d5 e5 ->
              Parsed ( if null i then s else StatementI s i ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappystatement d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyfragment d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5

testPappyParsePlusRule2 :: TestPappyDerivs -> Result TestPappyDerivs ([Clause])
testPappyParsePlusRule2 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyNIhO_clause d of
        Parsed v d3 e3 ->
          case testPappyPlusRule2 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 testPappyNIhO_clause d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule8 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule8 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule8 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 testPappyStarRule194 d of
            Parsed _ d5 e5 ->
              case testPappySU_clause d5 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) 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

testPappyParseStarRule9 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, [Free], Maybe Statement) ])
testPappyParseStarRule9 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule9 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 testPappyI_clause d of
            Parsed i d5 e5 ->
              case testPappyjek d5 of
                NoParse e7 ->
                  case testPappyjoik d5 of
                    NoParse e9 ->
                      case testPappyjoik_jek d5 of
                        NoParse e11 ->
                          case testPappyStarRule188 d5 of
                            Parsed f d13 e13 ->
                              case pappyResult15 of
                                Parsed s d15 e15 ->
                                  Parsed ( (i, f, s) ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case pappyResult17 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                                  where
                                    pappyResult17 =
                                      pappyAlt19_1 (ParseError (testPappyPos d13) []) where
                                        pappyAlt19_1 e19 =
                                          case testPappystatement d13 of
                                            Parsed v21 d21 e21 -> Parsed v21 d21 (max e21 e19)
                                            NoParse e21 -> pappyAlt19_2 (max e21 e19)
                                        pappyAlt19_2 e19 =
                                          case testPappyfragment d13 of
                                            Parsed v21 d21 e21 -> Parsed v21 d21 (max e21 e19)
                                            NoParse e21 -> pappyAlt19_3 (max e21 e19)
                                        pappyAlt19_3 e19 = NoParse e19
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                Parsed _ _ e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsestatement :: TestPappyDerivs -> Result TestPappyDerivs (Statement)
testPappyParsestatement d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappystatement_2 d of
        Parsed s d3 e3 ->
          case testPappyStarRule11 d3 of
            Parsed i d5 e5 ->
              Parsed ( if null i then s else IJoikJek s i ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyprenex d of
        Parsed p d3 e3 ->
          case testPappystatement d3 of
            Parsed s d5 e5 ->
              Parsed ( let (t, z, f) = p in Prenex t z f s ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule11 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, JoikJek, [Free], Maybe Statement) ])
testPappyParseStarRule11 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule11 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 testPappyI_clause d of
            Parsed i d5 e5 ->
              case testPappyjoik_jek d5 of
                Parsed j d7 e7 ->
                  case pappyResult9 of
                    Parsed s d9 e9 ->
                      Parsed ( (i, fst j, snd j, s) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappystatement_2 d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsestatement_2 :: TestPappyDerivs -> Result TestPappyDerivs (Statement)
testPappyParsestatement_2 d =
  case pappyResult1 of
    Parsed s3 d1 e1 ->
      case pappyResult3 of
        Parsed ib d3 e3 ->
          Parsed ( maybe s3 ($ s3) ib ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyI_clause d1 of
                Parsed i d7 e7 ->
                  case pappyResult9 of
                    Parsed j d9 e9 ->
                      case pappyResult11 of
                        Parsed t d11 e11 ->
                          case testPappyBO_clause d11 of
                            Parsed b d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed f d15 e15 ->
                                  case pappyResult17 of
                                    Parsed s d17 e17 ->
                                      Parsed ( \s3 -> maybe (IBO s3 i j t b f) (IBOStatement s3 i j t b f) s ) d17 (maximum [e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      case testPappystatement_2 d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                      where
                        pappyResult11 =
                          case testPappystag d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          pappyAlt13_1 (ParseError (testPappyPos d7) []) where
                            pappyAlt13_1 e13 =
                              case testPappyjek d7 of
                                Parsed v15 d15 e15 -> Parsed v15 d15 (max e15 e13)
                                NoParse e15 -> pappyAlt13_2 (max e15 e13)
                            pappyAlt13_2 e13 =
                              case testPappyjoik d7 of
                                Parsed v15 d15 e15 -> Parsed v15 d15 (max e15 e13)
                                NoParse e15 -> pappyAlt13_3 (max e15 e13)
                            pappyAlt13_3 e13 = NoParse e13
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappysentence 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 tag d5 e5 ->
              case testPappyTUhE_clause d5 of
                Parsed tuhe d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappytext_1 d9 of
                        Parsed text d11 e11 ->
                          case pappyResult13 of
                            Parsed tuhu d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed g d15 e15 ->
                                  Parsed ( TUhE tag tuhe f text tuhu g ) d15 (maximum [e15,e13,e11,e9,e7,e5,e3])
                                NoParse e15 -> pappyAlt3_3 (maximum [e15,e13,e11,e9,e7,e5,e3])
                            NoParse e13 -> pappyAlt3_3 (maximum [e13,e11,e9,e7,e5,e3])
                          where
                            pappyResult13 =
                              case pappyResult15 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                              where
                                pappyResult15 =
                                  case testPappyTUhU_pre d11 of
                                    Parsed p d17 e17 ->
                                      case testPappypost_clause d17 of
                                        Parsed q d19 e19 ->
                                          Parsed ( (fst p, snd p, q) ) d19 (max e19 e17)
                                        NoParse e19 -> NoParse (max e19 e17)
                                    NoParse e17 -> NoParse e17
                        NoParse e11 -> pappyAlt3_3 (maximum [e11,e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_3 (maximum [e9,e7,e5,e3])
                NoParse e7 -> pappyAlt3_3 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
          where
            pappyResult5 =
              case testPappytag d of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
        pappyAlt3_3 e3 = NoParse e3

testPappyParsefragment :: TestPappyDerivs -> Result TestPappyDerivs (Fragment)
testPappyParsefragment d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyprenex d of
        Parsed p d3 e3 ->
          Parsed ( uncurry3 FPrenex p ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyPlusRule3 d of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed v d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( FTermsVAU t v f ) d7 (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 testPappyVAU_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyek d of
        Parsed e d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( FEk e f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappygihek d of
        Parsed g d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( FGihek g f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyquantifier d of
        Parsed q d3 e3 ->
          Parsed ( FQuantifier q ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyNA_clause d of
        Parsed n d3 e3 ->
          case testPappyJA_clause d3 of
            NoParse e5 ->
              case testPappyStarRule188 d3 of
                Parsed f d7 e7 ->
                  Parsed ( FNA n f ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_7 (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_7 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappyrelative_clause d of
        Parsed r d3 e3 ->
          Parsed ( FRelativeClause r ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 =
      case testPappylinks d of
        Parsed l d3 e3 ->
          Parsed ( FLinks l ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
    pappyAlt1_9 e1 =
      case testPappylinkargs d of
        Parsed l d3 e3 ->
          Parsed ( FLinkargs l ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_10 (max e3 e1)
    pappyAlt1_10 e1 = NoParse e1

testPappyprenex :: TestPappyDerivs -> Result TestPappyDerivs ( ([Term], Clause, [Free]) )
testPappyprenex d =
  case testPappyPlusRule3 d of
    Parsed t d1 e1 ->
      case pappyResult3 of
        Parsed z d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (t, z, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyZOhU_pre d1 of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsesentence :: TestPappyDerivs -> Result TestPappyDerivs (Sentence)
testPappyParsesentence d =
  case pappyResult1 of
    Parsed h d1 e1 ->
      case testPappyStarRule21 d1 of
        Parsed _ d3 e3 ->
          case testPappybridi_tail d3 of
            Parsed bt d5 e5 ->
              Parsed ( maybe bt (\(ts, c, f) -> TermsBridiTail ts c f bt) h ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3
      where
        pappyResult3 =
          case testPappyPlusRule3 d of
            Parsed t d5 e5 ->
              case testPappyStarRule21 d5 of
                Parsed _ d7 e7 ->
                  case pappyResult9 of
                    Parsed c d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          Parsed ( (t, c, f) ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappyCU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5

testPappyParseStarRule21 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule21 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule21 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 testPappybridi_tail_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule26 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappybridi_tail d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule23 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule23 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule23 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 testPappysentence_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappysentence_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappysentence_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappysentence_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyI_pre d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyNIhO_pre d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsesubsentence :: TestPappyDerivs -> Result TestPappyDerivs (Sentence)
testPappyParsesubsentence d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappysentence d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyprenex d of
        Parsed p d3 e3 ->
          case testPappysubsentence d3 of
            Parsed s d5 e5 ->
              Parsed ( uncurry3 PrenexSentence p s ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsebridi_tail :: TestPappyDerivs -> Result TestPappyDerivs (Sentence)
testPappyParsebridi_tail d =
  case pappyResult1 of
    Parsed b d1 e1 ->
      case pappyResult3 of
        Parsed g d3 e3 ->
          Parsed ( maybe b (\(g, t, ke, f, b, kehe, h, (u, v, i)) ->
		GihekKE b g t ke f b kehe h u v i) g ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappygihek d1 of
                Parsed g d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyKE_clause d9 of
                        Parsed ke d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappybridi_tail d13 of
                                Parsed b d15 e15 ->
                                  case pappyResult17 of
                                    Parsed kehe d17 e17 ->
                                      case testPappyStarRule188 d17 of
                                        Parsed h d19 e19 ->
                                          case testPappytail_terms d19 of
                                            Parsed tts d21 e21 ->
                                              Parsed ( (g, t, ke, f, b, kehe, h, tts) ) d21 (maximum [e21,e19,e17,e15,e13,e11,e9,e7])
                                            NoParse e21 -> NoParse (maximum [e21,e19,e17,e15,e13,e11,e9,e7])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      case testPappyKEhE_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappybridi_tail_2 d of
        Parsed b d3 e3 ->
          case testPappyStarRule27 d3 of
            Parsed g d5 e5 ->
              Parsed ( if null g then b else GihekSentence b g ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParseStarRule26 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule26 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule26 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyterm d of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappybridi_tail_start d of
                NoParse e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      Parsed ( () ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (testPappyPos d) []) where
                        pappyAlt11_1 e11 =
                          case testPappypre_zei_bu d of
                            Parsed _ d13 e13 ->
                              Parsed ( () ) d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_2 (max e13 e11)
                        pappyAlt11_2 e11 =
                          case testPappySA_clause d of
                            Parsed _ d13 e13 ->
                              case testPappybridi_tail_start d13 of
                                NoParse e15 ->
                                  Parsed ( () ) d13 (maximum [e15,e13,e11])
                                Parsed _ _ e15 -> pappyAlt11_3 (maximum [e15,e13,e11])
                            NoParse e13 -> pappyAlt11_3 (max e13 e11)
                        pappyAlt11_3 e11 = NoParse e11
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsebridi_tail_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParsebridi_tail_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyME_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyNUhA_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyNU_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyNA_clause d of
        Parsed _ d3 e3 ->
          case testPappyKU_clause d3 of
            NoParse e5 ->
              Parsed ( () ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyNAhE_clause d of
        Parsed _ d3 e3 ->
          case testPappyBO_clause d3 of
            NoParse e5 ->
              Parsed ( () ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyselbri d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappytag d of
        Parsed _ d3 e3 ->
          case testPappybridi_tail_start d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_8 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 =
      case testPappyKE_clause d of
        Parsed _ d3 e3 ->
          case testPappybridi_tail_start d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_9 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
    pappyAlt1_9 e1 =
      case testPappybridi_tail d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_10 (max e3 e1)
    pappyAlt1_10 e1 = NoParse e1

testPappyParseStarRule27 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Gihek, [Free], Sentence, [Term], Maybe Clause, [Free]) ])
testPappyParseStarRule27 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule27 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 testPappygihek d of
            Parsed g d5 e5 ->
              case pappyResult7 of
                NoParse e7 ->
                  case pappyResult9 of
                    NoParse e9 ->
                      case testPappyStarRule188 d5 of
                        Parsed f d11 e11 ->
                          case testPappybridi_tail_2 d11 of
                            Parsed b d13 e13 ->
                              case testPappytail_terms d13 of
                                Parsed tvi d15 e15 ->
                                  Parsed ( let (t, v, i) = tvi in (g, f, b, t, v, i) ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7,e5])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed _ d11 e11 ->
                          case testPappyKE_clause d11 of
                            Parsed _ d13 e13 ->
                              Parsed ( () ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
                      where
                        pappyResult11 =
                          case testPappystag d5 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d5 e13
                Parsed _ _ e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      case testPappyBO_clause d9 of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
                  where
                    pappyResult9 =
                      case testPappystag d5 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d5 e11
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsebridi_tail_2 :: TestPappyDerivs -> Result TestPappyDerivs (Sentence)
testPappyParsebridi_tail_2 d =
  case pappyResult1 of
    Parsed b3 d1 e1 ->
      case pappyResult3 of
        Parsed g d3 e3 ->
          Parsed ( maybe b3 (\(h, s, bo, f, bt, (t, v, i)) -> GihekBO b3 h s bo f bt t v i) g ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappygihek d1 of
                Parsed g d7 e7 ->
                  case pappyResult9 of
                    Parsed s d9 e9 ->
                      case testPappyBO_clause d9 of
                        Parsed bo d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappybridi_tail_2 d13 of
                                Parsed bt d15 e15 ->
                                  case testPappytail_terms d15 of
                                    Parsed t d17 e17 ->
                                      Parsed ( (g, s, bo, f, bt, t) ) d17 (maximum [e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappyselbri d of
            Parsed s d5 e5 ->
              case testPappytail_terms d5 of
                Parsed tvf d7 e7 ->
                  Parsed ( case tvf of ([], Nothing, []) -> Selbri s; (t, v, f) -> SelbriTailTerms s t v f ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_2 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappygek_sentence d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

testPappyParsegek_sentence :: TestPappyDerivs -> Result TestPappyDerivs (Sentence)
testPappyParsegek_sentence d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappygek d of
        Parsed gek d3 e3 ->
          case testPappysubsentence d3 of
            Parsed s d5 e5 ->
              case testPappygik d5 of
                Parsed gik d7 e7 ->
                  case testPappysubsentence d7 of
                    Parsed t d9 e9 ->
                      case testPappytail_terms d9 of
                        Parsed tts d11 e11 ->
                          Parsed ( uncurry3 (GekSentence gek s gik t) tts ) 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 pappyResult3 of
        Parsed t d3 e3 ->
          case testPappyKE_clause d3 of
            Parsed ke d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappygek_sentence d7 of
                    Parsed gs d9 e9 ->
                      case pappyResult11 of
                        Parsed kehe d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed g d13 e13 ->
                              Parsed ( KEGekSentence t ke f gs kehe g ) d13 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_3 (maximum [e13,e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_3 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case testPappyKEhE_clause d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    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)
      where
        pappyResult3 =
          case testPappytag d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case testPappyNA_clause d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappygek_sentence d5 of
                Parsed gs d7 e7 ->
                  Parsed ( NAGekSentence n f gs ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappytail_terms :: TestPappyDerivs -> Result TestPappyDerivs ( ([Term], Maybe Clause, [Free]) )
testPappytail_terms d =
  case pappyResult1 of
    Parsed t d1 e1 ->
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (fromMaybe [] t, v, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyVAU_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyPlusRule3 d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParsePlusRule3 :: TestPappyDerivs -> Result TestPappyDerivs ([Term])
testPappyParsePlusRule3 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyterms_1 d of
        Parsed v d3 e3 ->
          case testPappyPlusRule3 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 testPappyterms_1 d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule34 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, [Free], JoikJek, [Free], Term) ])
testPappyParseStarRule34 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule34 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 testPappyStarRule35 d of
            Parsed _ d5 e5 ->
              case testPappyPEhE_clause d5 of
                Parsed p d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyjoik_jek d9 of
                        Parsed j d11 e11 ->
                          case testPappyterms_2 d11 of
                            Parsed t d13 e13 ->
                              Parsed ( (p, f, fst j, snd j, t) ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyterms_1 :: TestPappyDerivs -> Result TestPappyDerivs (Term)
testPappyterms_1 d =
  case testPappyterms_2 d of
    Parsed t d1 e1 ->
      case testPappyStarRule34 d1 of
        Parsed pfjt d3 e3 ->
          Parsed ( if null pfjt then t else TermsPEhETerms t pfjt ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule35 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule35 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule35 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 testPappyPEhE_clause d of
            Parsed _ d5 e5 ->
              case testPappyStarRule40 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause 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 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule37 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, [Free], Term) ])
testPappyParseStarRule37 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule37 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 testPappyStarRule38 d of
            Parsed _ d5 e5 ->
              case testPappyCEhE_clause d5 of
                Parsed c d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyterm d9 of
                        Parsed t d11 e11 ->
                          Parsed ( (c, f, t) ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyterms_2 :: TestPappyDerivs -> Result TestPappyDerivs (Term)
testPappyterms_2 d =
  case testPappyterm d of
    Parsed t d1 e1 ->
      case testPappyStarRule37 d1 of
        Parsed cft d3 e3 ->
          Parsed ( if null cft then t else TermCEhETerm t cft ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule38 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule38 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule38 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 testPappyCEhE_clause d of
            Parsed _ d5 e5 ->
              case testPappyStarRule41 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause 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 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule40 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule40 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule40 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 testPappyPEhE_clause d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyPEhE_clause d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule41 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule41 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule41 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 testPappyCEhE_clause d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyCEhE_clause d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule42 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule42 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule42 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 testPappyterm_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule46 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappyterm_1 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyterm :: TestPappyDerivs -> Result TestPappyDerivs (Term)
testPappyterm d =
  case testPappyStarRule42 d of
    Parsed _ d1 e1 ->
      case testPappyterm_1 d1 of
        Parsed t d3 e3 ->
          Parsed ( t ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseterm_1 :: TestPappyDerivs -> Result TestPappyDerivs (Term)
testPappyParseterm_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappysumti d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappygek d of
        NoParse e3 ->
          case pappyResult5 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed s d7 e7 ->
                  Parsed ( TagSumti t s ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d5) []) where
                    pappyAlt9_1 e9 =
                      case testPappysumti d5 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case pappyResult11 of
                        Parsed k d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              Parsed ( KU k f ) d13 (maximum [e13,e11,e9])
                            NoParse e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                      where
                        pappyResult11 =
                          case testPappyKU_clause d5 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d5 e13
                    pappyAlt9_3 e9 = NoParse e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappytag d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyFA_clause d of
                    Parsed fa d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          Parsed ( FA fa f ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_3 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
        Parsed _ _ e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      pappyAlt3_1 e1 where
        pappyAlt3_1 e3 =
          case testPappygek d of
            Parsed g d5 e5 ->
              case testPappyterms_gik_terms d5 of
                Parsed tgt d7 e7 ->
                  Parsed ( Gek g tgt ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_2 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappyNUhI_clause d of
            Parsed nuhi d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappygek d7 of
                    Parsed gek d9 e9 ->
                      case testPappyPlusRule3 d9 of
                        Parsed t d11 e11 ->
                          case pappyResult13 of
                            Parsed nuhu d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed g d15 e15 ->
                                  case testPappygik d15 of
                                    Parsed gik d17 e17 ->
                                      case testPappyPlusRule3 d17 of
                                        Parsed u d19 e19 ->
                                          case pappyResult21 of
                                            Parsed nuhu2 d21 e21 ->
                                              case testPappyStarRule188 d21 of
                                                Parsed h d23 e23 ->
                                                  Parsed ( NUhIGek nuhi f gek t nuhu g gik u nuhu2 h ) d23 (maximum [e23,e21,e19,e17,e15,e13,e11,e9,e7,e5,e3])
                                                NoParse e23 -> pappyAlt3_3 (maximum [e23,e21,e19,e17,e15,e13,e11,e9,e7,e5,e3])
                                            NoParse e21 -> pappyAlt3_3 (maximum [e21,e19,e17,e15,e13,e11,e9,e7,e5,e3])
                                          where
                                            pappyResult21 =
                                              case testPappyNUhU_clause d19 of
                                                Parsed v23 d23 e23 -> Parsed (Just v23) d23 e23
                                                NoParse e23 -> Parsed (Nothing) d19 e23
                                        NoParse e19 -> pappyAlt3_3 (maximum [e19,e17,e15,e13,e11,e9,e7,e5,e3])
                                    NoParse e17 -> pappyAlt3_3 (maximum [e17,e15,e13,e11,e9,e7,e5,e3])
                                NoParse e15 -> pappyAlt3_3 (maximum [e15,e13,e11,e9,e7,e5,e3])
                            NoParse e13 -> pappyAlt3_3 (maximum [e13,e11,e9,e7,e5,e3])
                          where
                            pappyResult13 =
                              case testPappyNUhU_clause d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt3_3 (maximum [e11,e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_3 (maximum [e9,e7,e5,e3])
                NoParse e7 -> pappyAlt3_3 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case testPappyNUhI_clause d of
            Parsed nuhi d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappyPlusRule3 d7 of
                    Parsed t d9 e9 ->
                      case pappyResult11 of
                        Parsed nuhu d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed g d13 e13 ->
                              Parsed ( NUhI nuhi f t nuhu g ) d13 (maximum [e13,e11,e9,e7,e5,e3])
                            NoParse e13 -> pappyAlt3_4 (maximum [e13,e11,e9,e7,e5,e3])
                        NoParse e11 -> pappyAlt3_4 (maximum [e11,e9,e7,e5,e3])
                      where
                        pappyResult11 =
                          case testPappyNUhU_clause d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt3_4 (maximum [e9,e7,e5,e3])
                NoParse e7 -> pappyAlt3_4 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 = pappyAlt1_4 e3
    pappyAlt1_4 e1 =
      case testPappyNA_clause d of
        Parsed n d3 e3 ->
          case testPappyKU_clause d3 of
            Parsed k d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( NAKU n k f ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 = NoParse e1

testPappyParseStarRule46 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule46 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule46 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 testPappyterm_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyterm_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseterm_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParseterm_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyterm_1 d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyLA_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyLE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyLI_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyLU_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyLAhE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappyquantifier d of
        Parsed _ d3 e3 ->
          case testPappyterm_start d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_8 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 =
      case testPappygek d of
        Parsed _ d3 e3 ->
          case testPappysumti d3 of
            Parsed _ d5 e5 ->
              case testPappygik d5 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_9 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_9 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
    pappyAlt1_9 e1 =
      case testPappyFA_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_10 (max e3 e1)
    pappyAlt1_10 e1 =
      case testPappytag d of
        Parsed _ d3 e3 ->
          case testPappyterm_start d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_11 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_11 (max e3 e1)
    pappyAlt1_11 e1 = NoParse e1

testPappyParseterms_gik_terms :: TestPappyDerivs -> Result TestPappyDerivs (TermsGikTerms)
testPappyParseterms_gik_terms d =
  case testPappyterm d of
    Parsed t1 d1 e1 ->
      case pappyResult3 of
        Parsed tgt d3 e3 ->
          case testPappyterm d3 of
            Parsed t2 d5 e5 ->
              Parsed ( TGT t1 tgt t2 ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappygik d1 of
                Parsed g d7 e7 ->
                  Parsed ( Gik g ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyterms_gik_terms d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsesumti :: TestPappyDerivs -> Result TestPappyDerivs (Sumti)
testPappyParsesumti d =
  case pappyResult1 of
    Parsed s d1 e1 ->
      case pappyResult3 of
        Parsed vr d3 e3 ->
          Parsed ( maybe s (\(v, f, r) -> VUhO s v f r) vr ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyrelative_clauses d9 of
                        Parsed r d11 e11 ->
                          Parsed ( (v, f, r) ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
              where
                pappyResult7 =
                  case testPappyVUhO_pre d1 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed s2 d3 e3 ->
          case pappyResult5 of
            Parsed s d5 e5 ->
              Parsed ( maybe s2 (\((je, f), t, k, g, s, l, h) -> JoikEkKESumti s2 je f t k g s l h) s ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  case testPappyjoik_ek d3 of
                    Parsed je d9 e9 ->
                      case pappyResult11 of
                        Parsed t d11 e11 ->
                          case testPappyKE_clause d11 of
                            Parsed k d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed f d15 e15 ->
                                  case testPappysumti d15 of
                                    Parsed s d17 e17 ->
                                      case pappyResult19 of
                                        Parsed l d19 e19 ->
                                          case testPappyStarRule188 d19 of
                                            Parsed g d21 e21 ->
                                              Parsed ( (je, t, k, f, s, l, g) ) d21 (maximum [e21,e19,e17,e15,e13,e11,e9])
                                            NoParse e21 -> NoParse (maximum [e21,e19,e17,e15,e13,e11,e9])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e15,e13,e11,e9])
                                      where
                                        pappyResult19 =
                                          case testPappyKEhE_clause d17 of
                                            Parsed v21 d21 e21 -> Parsed (Just v21) d21 e21
                                            NoParse e21 -> Parsed (Nothing) d17 e21
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9])
                        NoParse e11 -> NoParse (max e11 e9)
                      where
                        pappyResult11 =
                          case testPappystag d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse e9
        NoParse e3 -> NoParse e3
      where
        pappyResult3 =
          case testPappysumti_3 d of
            Parsed s d5 e5 ->
              case testPappyStarRule55 d5 of
                Parsed ss d7 e7 ->
                  Parsed ( if null ss then s else JoikEkSumti s ss ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5

testPappyParseStarRule55 :: TestPappyDerivs -> Result TestPappyDerivs ([ (JoikEk, [Free], Sumti) ])
testPappyParseStarRule55 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule55 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 testPappyjoik_ek d of
            Parsed jf d5 e5 ->
              case testPappysumti_3 d5 of
                Parsed s d7 e7 ->
                  Parsed ( (fst jf, snd jf, s) ) 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

testPappyParsesumti_3 :: TestPappyDerivs -> Result TestPappyDerivs (Sumti)
testPappyParsesumti_3 d =
  case testPappysumti_4 d of
    Parsed s4 d1 e1 ->
      case pappyResult3 of
        Parsed s3 d3 e3 ->
          Parsed ( maybe s4 (\((je, f), t, b, g, s) -> JoikEkBOSumti s4 je f t b g s) s3 ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyjoik_ek d1 of
                Parsed je d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyBO_clause d9 of
                        Parsed b d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappysumti_3 d13 of
                                Parsed s d15 e15 ->
                                  Parsed ( (je, t, b, f, s) ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1

testPappyParsesumti_4 :: TestPappyDerivs -> Result TestPappyDerivs (Sumti)
testPappyParsesumti_4 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed q d3 e3 ->
          case testPappysumti_6 d3 of
            Parsed s d5 e5 ->
              case pappyResult7 of
                Parsed r d7 e7 ->
                  Parsed ( if isNothing q && isNothing r then s else OuterQuantifier q s r ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyrelative_clauses 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)
      where
        pappyResult3 =
          case testPappyquantifier d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_2 e1 =
      case testPappyquantifier d of
        Parsed q d3 e3 ->
          case testPappyselbri d3 of
            Parsed s d5 e5 ->
              case pappyResult7 of
                Parsed k d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case pappyResult11 of
                        Parsed r d11 e11 ->
                          Parsed ( SQuantifierSelbri q s k f r ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_3 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case testPappyrelative_clauses d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyKU_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappygek d of
        Parsed ge d3 e3 ->
          case testPappysumti d3 of
            Parsed s d5 e5 ->
              case testPappygik d5 of
                Parsed gi d7 e7 ->
                  case testPappysumti_4 d7 of
                    Parsed s4 d9 e9 ->
                      Parsed ( GekSumti ge s gi s4 ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParsesumti_6 :: TestPappyDerivs -> Result TestPappyDerivs (Sumti)
testPappyParsesumti_6 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed zo d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( let (pre, z, w, q) = zo in ZO pre z w q f ) 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 p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( let (pre, z, w) = p in (pre, z, w, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappypre_clause d of
                Parsed p d7 e7 ->
                  case testPappyZO d7 of
                    Parsed z d9 e9 ->
                      case pappyResult11 of
                        Parsed _ d11 e11 ->
                          case testPappyany_word d11 of
                            Parsed w d13 e13 ->
                              case pappyResult15 of
                                Parsed _ d15 e15 ->
                                  Parsed ( (p, z, w) ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                              where
                                pappyResult15 =
                                  case testPappyspaces d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                      where
                        pappyResult11 =
                          case testPappyspaces d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed z d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( let (pre, zoi, ws, q) = z in ZOI pre zoi ws q f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( let (pre, z, ws) = p in (pre, z, ws, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappypre_clause d of
                Parsed p d7 e7 ->
                  case testPappyZOI d7 of
                    Parsed z d9 e9 ->
                      case pappyResult11 of
                        Parsed _ d11 e11 ->
                          case testPappyChar d11 of
                            Parsed w d13 e13 ->
                              case ( w == '\NUL' ) of
                                True ->
                                  case pappyResult17 of
                                    Parsed s d17 e17 ->
                                      case testPappyStarRule198 d17 of
                                        Parsed ws d19 e19 ->
                                          case testPappyChar d19 of
                                            Parsed v d21 e21 ->
                                              case ( v == '\NUL' ) of
                                                True ->
                                                  case pappyResult25 of
                                                    Parsed _ d25 e25 ->
                                                      Parsed ( (p, z, maybe ws (: ws) s) ) d25 (maximum [e25,e21,e19,e17,e13,e11,e9,e7])
                                                    NoParse e25 -> NoParse (maximum [e25,e21,e19,e17,e13,e11,e9,e7])
                                                  where
                                                    pappyResult25 =
                                                      case testPappyspaces d21 of
                                                        Parsed v27 d27 e27 -> Parsed (Just v27) d27 e27
                                                        NoParse e27 -> Parsed (Nothing) d21 e27
                                                False -> NoParse (maximum [e21,e19,e17,e13,e11,e9,e7])
                                            NoParse e21 -> NoParse (maximum [e21,e19,e17,e13,e11,e9,e7])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      case testPappyspaces d13 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d13 e19
                                False -> NoParse (maximum [e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                      where
                        pappyResult11 =
                          case testPappyspaces d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed l d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( let (p, lohu, ws, lehu, q) = l in LOhU p lohu ws lehu q f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed lp d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( let (p, lohu, ws, lehu) = lp in (p, lohu, ws, lehu, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappypre_clause d of
                Parsed p d7 e7 ->
                  case testPappyLOhU d7 of
                    Parsed lohu d9 e9 ->
                      case pappyResult11 of
                        Parsed _ d11 e11 ->
                          case testPappyStarRule196 d11 of
                            Parsed ws d13 e13 ->
                              case testPappyLEhU_pre d13 of
                                Parsed lehu d15 e15 ->
                                  case pappyResult17 of
                                    Parsed _ d17 e17 ->
                                      Parsed ( (p, lohu, ws, lehu) ) d17 (maximum [e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      case testPappyspaces d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                      where
                        pappyResult11 =
                          case testPappyspaces d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    pappyAlt1_4 e1 =
      case testPappylerfu_string d of
        Parsed l d3 e3 ->
          case testPappyMOI_clause d3 of
            NoParse e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      Parsed ( LerfuString l b f ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyBOI_clause d3 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d3 e9
            Parsed _ _ e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyLU_clause d of
        Parsed lu d3 e3 ->
          case testPappytext d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed lihu d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      Parsed ( LU lu t lihu f ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_6 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_6 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed p d11 e11 ->
                          case testPappypost_clause d11 of
                            Parsed q d13 e13 ->
                              Parsed ( (fst p, snd p, q) ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
                      where
                        pappyResult11 =
                          case testPappypre_clause d5 of
                            Parsed p d13 e13 ->
                              case testPappyLIhU d13 of
                                Parsed l d15 e15 ->
                                  case pappyResult17 of
                                    Parsed _ d17 e17 ->
                                      Parsed ( (p, l) ) d17 (maximum [e17,e15,e13])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13])
                                  where
                                    pappyResult17 =
                                      case testPappyspaces d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
            NoParse e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyLAhE_NAhE d of
        Parsed lnbf d3 e3 ->
          case pappyResult5 of
            Parsed r d5 e5 ->
              case testPappysumti d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed l d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( let (ln, b, f) = lnbf in LAhE_NAhE ln  b f r s l g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_7 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_7 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyLUhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_7 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_7 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyrelative_clauses d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case pappyResult3 of
        Parsed k d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( KOhA k f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_8 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
      where
        pappyResult3 =
          case testPappyKOhA_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_8 e1 =
      case testPappyLA_clause d of
        Parsed l d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case pappyResult7 of
                Parsed r d7 e7 ->
                  case testPappyPlusRule12 d7 of
                    Parsed c d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( LA l f r c g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_9 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_9 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_9 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyrelative_clauses d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_9 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
    pappyAlt1_9 e1 =
      case pappyResult3 of
        Parsed l d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case pappyResult7 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed k d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( LALE l f s k g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_10 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_10 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyKU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_10 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d5) []) where
                    pappyAlt9_1 e9 =
                      case pappyResult11 of
                        Parsed s6 d11 e11 ->
                          case testPappysumti_tail_1 d11 of
                            Parsed st d13 e13 ->
                              Parsed ( maybe st (\(s, r) -> SumtiSumtiTail s r st) s6 ) d13 (maximum [e13,e11,e9])
                            NoParse e13 -> pappyAlt9_2 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d5 e13
                          where
                            pappyResult13 =
                              case testPappysumti_6 d5 of
                                Parsed s d15 e15 ->
                                  case pappyResult17 of
                                    Parsed r d17 e17 ->
                                      Parsed ( (s, r) ) d17 (max e17 e15)
                                    NoParse e17 -> NoParse (max e17 e15)
                                  where
                                    pappyResult17 =
                                      case testPappyrelative_clauses d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse e15
                    pappyAlt9_2 e9 =
                      case testPappyrelative_clauses d5 of
                        Parsed r d11 e11 ->
                          case testPappysumti_tail_1 d11 of
                            Parsed s d13 e13 ->
                              Parsed ( RelativeClausesSumtiTail r s ) d13 (maximum [e13,e11,e9])
                            NoParse e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            NoParse e5 -> pappyAlt1_10 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_10 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyLA_clause d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyLE_clause d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_10 e1 =
      case pappyResult3 of
        Parsed l d3 e3 ->
          Parsed ( let (li, f, m, loho, g) = l in LI li f m loho g ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_11 (max e3 e1)
      where
        pappyResult3 =
          case testPappyLI_clause d of
            Parsed li d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappymex d7 of
                    Parsed m d9 e9 ->
                      case pappyResult11 of
                        Parsed loho d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed g d13 e13 ->
                              Parsed ( (li, f, m, loho, g) ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                          where
                            pappyResult13 =
                              case pappyResult15 of
                                Parsed p d15 e15 ->
                                  case testPappypost_clause d15 of
                                    Parsed q d17 e17 ->
                                      Parsed ( (fst p, snd p, q) ) d17 (max e17 e15)
                                    NoParse e17 -> NoParse (max e17 e15)
                                NoParse e15 -> NoParse e15
                              where
                                pappyResult15 =
                                  case testPappypre_clause d9 of
                                    Parsed p d17 e17 ->
                                      case testPappyLOhO d17 of
                                        Parsed l d19 e19 ->
                                          case pappyResult21 of
                                            Parsed _ d21 e21 ->
                                              Parsed ( (p, l) ) d21 (maximum [e21,e19,e17])
                                            NoParse e21 -> NoParse (maximum [e21,e19,e17])
                                          where
                                            pappyResult21 =
                                              case testPappyspaces d19 of
                                                Parsed v23 d23 e23 -> Parsed (Just v23) d23 e23
                                                NoParse e23 -> Parsed (Nothing) d19 e23
                                        NoParse e19 -> NoParse (max e19 e17)
                                    NoParse e17 -> NoParse e17
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_11 e1 = NoParse e1

testPappyParseLAhE_NAhE :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, Maybe Clause, [Free]) )
testPappyParseLAhE_NAhE d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyLAhE_clause d of
        Parsed l d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (l, Nothing, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyNAhE_clause d of
        Parsed n d3 e3 ->
          case testPappyBO_clause d3 of
            Parsed b d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( (n, Just b, f) ) d7 (maximum [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

testPappysumti_tail_1 :: TestPappyDerivs -> Result TestPappyDerivs (SumtiTail)
testPappysumti_tail_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyselbri d of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed r d5 e5 ->
              Parsed ( SelbriRelativeClauses s r ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyrelative_clauses d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyquantifier d of
        Parsed q d3 e3 ->
          case testPappyselbri d3 of
            Parsed s d5 e5 ->
              case pappyResult7 of
                Parsed r d7 e7 ->
                  Parsed ( STQuantifierSelbri q s r ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyrelative_clauses d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyquantifier d of
        Parsed q d3 e3 ->
          case testPappysumti d3 of
            Parsed s d5 e5 ->
              Parsed ( QuantifierSumti q s ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseStarRule73 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, [Free], RelativeClause) ])
testPappyParseStarRule73 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule73 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 z d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappyrelative_clause d7 of
                    Parsed rc d9 e9 ->
                      Parsed ( (z, f, rc) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappyZIhE_pre d of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyrelative_clauses :: TestPappyDerivs -> Result TestPappyDerivs (RelativeClauses)
testPappyrelative_clauses d =
  case testPappyrelative_clause d of
    Parsed rc d1 e1 ->
      case testPappyStarRule73 d1 of
        Parsed z d3 e3 ->
          Parsed ( if null z then rc else RelativeClauseZIhE rc z ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule75 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule75 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule75 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 testPappyrelative_clause_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule76 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappyrelative_clause_1 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyrelative_clause :: TestPappyDerivs -> Result TestPappyDerivs (RelativeClause)
testPappyrelative_clause d =
  case testPappyStarRule75 d of
    Parsed _ d1 e1 ->
      case testPappyrelative_clause_1 d1 of
        Parsed rc d3 e3 ->
          Parsed ( rc ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule76 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule76 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule76 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 testPappyrelative_clause_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyrelative_clause_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParserelative_clause_1 :: TestPappyDerivs -> Result TestPappyDerivs (RelativeClause)
testPappyParserelative_clause_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyGOI_clause d of
        Parsed goi d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyterm d5 of
                Parsed t d7 e7 ->
                  case pappyResult9 of
                    Parsed gehu d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( GOI goi f t gehu g ) 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])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case testPappyGEhU_pre d7 of
                            Parsed p d13 e13 ->
                              case testPappypost_clause d13 of
                                Parsed q d15 e15 ->
                                  Parsed ( (fst p, snd p, q) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                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 testPappyNOI_clause d of
        Parsed noi d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappysubsentence d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed kuho d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( NOI noi f s kuho g ) 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])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case testPappyKUhO_pre d7 of
                            Parsed p d13 e13 ->
                              case testPappypost_clause d13 of
                                Parsed q d15 e15 ->
                                  Parsed ( (fst p, snd p, q) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                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

testPappyrelative_clause_start :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyrelative_clause_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyGOI_clause d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyNOI_clause d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseselbri :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyParseselbri d =
  case pappyResult1 of
    Parsed t d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          Parsed ( maybe s (flip Tag s) t ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyselbri_2 d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyNA_clause d1 of
                Parsed n d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyselbri d9 of
                        Parsed s d11 e11 ->
                          Parsed ( NA n f s ) 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
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappytag d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParseselbri_2 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyParseselbri_2 d =
  case pappyResult1 of
    Parsed s3 d1 e1 ->
      case pappyResult3 of
        Parsed s2 d3 e3 ->
          Parsed ( maybe s3 (uncurry3 $ CO s3) s2 ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed c d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyselbri_2 d9 of
                        Parsed s d11 e11 ->
                          Parsed ( (c, f, s) ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
              where
                pappyResult7 =
                  case testPappyCO_pre d1 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyPlusRule5 d of
        Parsed s d3 e3 ->
          Parsed ( case s of [t] -> t; _ -> Tanru s ) d3 e3
        NoParse e3 -> NoParse e3

testPappyParsePlusRule5 :: TestPappyDerivs -> Result TestPappyDerivs ([Selbri])
testPappyParsePlusRule5 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyselbri_4 d of
        Parsed v d3 e3 ->
          case testPappyPlusRule5 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 testPappyselbri_4 d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule83 :: TestPappyDerivs -> Result TestPappyDerivs ([JoikJekSelbri5])
testPappyParseStarRule83 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule83 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyjoik_jek d of
                Parsed jf d7 e7 ->
                  case testPappyselbri_5 d7 of
                    Parsed s d9 e9 ->
                      Parsed ( let (j, f) = jf in Left (j, f, s) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyjoik d of
                Parsed j d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyKE_clause d9 of
                        Parsed k d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case pappyResult15 of
                                Parsed s d15 e15 ->
                                  case pappyResult17 of
                                    Parsed l d17 e17 ->
                                      case testPappyStarRule188 d17 of
                                        Parsed g d19 e19 ->
                                          Parsed ( Right (j, t, k, f, s, l, g) ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                        NoParse e19 -> pappyAlt5_3 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                    NoParse e17 -> pappyAlt5_3 (maximum [e17,e15,e13,e11,e9,e7,e5])
                                  where
                                    pappyResult17 =
                                      case testPappyKEhE_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> pappyAlt5_3 (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case testPappyPlusRule5 d13 of
                                    Parsed s d17 e17 ->
                                      Parsed ( case s of [t] -> t; _ -> Tanru s ) d17 e17
                                    NoParse e17 -> NoParse e17
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyselbri_4 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyselbri_4 d =
  case testPappyselbri_5 d of
    Parsed s d1 e1 ->
      case testPappyStarRule83 d1 of
        Parsed js d3 e3 ->
          Parsed ( if null js then s else JoikJek s js ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseselbri_5 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyParseselbri_5 d =
  case testPappyselbri_6 d of
    Parsed s6 d1 e1 ->
      case pappyResult3 of
        Parsed jb d3 e3 ->
          Parsed ( maybe s6 (\(j, t, b, f, s5) -> JekJoikBO s6 j t b f s5) jb ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed j d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyBO_clause d9 of
                        Parsed b d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappyselbri_5 d13 of
                                Parsed s d15 e15 ->
                                  Parsed ( (j, t, b, f, s) ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d1) []) where
                    pappyAlt9_1 e9 =
                      case testPappyjek d1 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappyjoik d1 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
    NoParse e1 -> NoParse e1

testPappyParseselbri_6 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyParseselbri_6 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed b d5 e5 ->
              Parsed ( maybe t (uncurry3 $ BO t) b ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  case testPappyBO_clause d3 of
                    Parsed b d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          case testPappyselbri_6 d11 of
                            Parsed s d13 e13 ->
                              Parsed ( (b, f, s) ) d13 (maximum [e13,e11,e9])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9])
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case testPappytanru_unit_1 d of
            Parsed t d5 e5 ->
              case testPappyStarRule89 d5 of
                Parsed cs d7 e7 ->
                  Parsed ( if null cs then t else CEI t cs ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyguhek d5 of
                Parsed gu d7 e7 ->
                  case testPappyselbri d7 of
                    Parsed s d9 e9 ->
                      case testPappygik d9 of
                        Parsed gi d11 e11 ->
                          case testPappyselbri_6 d11 of
                            Parsed s6 d13 e13 ->
                              Parsed ( GuhekGik n f gu s gi s6 ) d13 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_3 (maximum [e13,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)
      where
        pappyResult3 =
          case testPappyNAhE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule89 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, [Free], Selbri) ])
testPappyParseStarRule89 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule89 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 c d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappytanru_unit_1 d7 of
                    Parsed u d9 e9 ->
                      Parsed ( (c, f, u) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappyCEI_pre d of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappytanru_unit_1 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappytanru_unit_1 d =
  case testPappytanru_unit_2 d of
    Parsed t d1 e1 ->
      case pappyResult3 of
        Parsed l d3 e3 ->
          Parsed ( maybe t (Linkargs t) l ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappylinkargs d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyParseStarRule104 :: TestPappyDerivs -> Result TestPappyDerivs ([ (JoikJek, [Free], Clause, Maybe Clause, [Free]) ])
testPappyParseStarRule104 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule104 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 testPappyjoik_jek d of
            Parsed j d5 e5 ->
              case testPappyNU_clause d5 of
                Parsed nu d7 e7 ->
                  case pappyResult9 of
                    Parsed nai d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          Parsed ( (fst j, snd j, nu, nai, f) ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappyNAI_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsetanru_unit_2 :: TestPappyDerivs -> Result TestPappyDerivs (Selbri)
testPappyParsetanru_unit_2 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed b d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( Brivla b f ) 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyBRIVLA_pre d of
                Parsed pre d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed post d9 e9 ->
                      Parsed ( let (bahe, brivla) = pre in (bahe, brivla, post) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappypre_clause d of
                Parsed p d7 e7 ->
                  case testPappyzei_clause_no_pre d7 of
                    Parsed z d9 e9 ->
                      Parsed ( (p, fst z, snd z) ) 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
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed r d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( GOhA g r f ) d7 (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 pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  case testPappyRAhO_pre d3 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyGOhA_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_3 e1 =
      case testPappyKE_clause d of
        Parsed ke d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case pappyResult7 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed kehe d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( KE ke f s kehe g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_4 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyKEhE_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyPlusRule5 d5 of
                    Parsed s d9 e9 ->
                      Parsed ( case s of [t] -> t; _ -> Tanru s ) d9 e9
                    NoParse e9 -> NoParse e9
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyME_clause d of
        Parsed me d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case pappyResult7 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed mehu d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          case pappyResult13 of
                            Parsed m d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed h d15 e15 ->
                                  Parsed ( ME me f s mehu g m h ) d15 (maximum [e15,e13,e11,e9,e7,e5,e3,e1])
                                NoParse e15 -> pappyAlt1_5 (maximum [e15,e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_5 (maximum [e13,e11,e9,e7,e5,e3,e1])
                          where
                            pappyResult13 =
                              case testPappyMOI_clause d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt1_5 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case testPappyMEhU_pre d7 of
                            Parsed p d13 e13 ->
                              case testPappypost_clause d13 of
                                Parsed q d15 e15 ->
                                  Parsed ( (fst p, snd p, q) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d5) []) where
                    pappyAlt9_1 e9 =
                      case testPappysumti d5 of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappylerfu_string d5 of
                        Parsed l d11 e11 ->
                          Parsed ( LerfuString l Nothing [] ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case pappyResult3 of
        Parsed n d3 e3 ->
          case testPappyMOI_clause d3 of
            Parsed m d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( MOI n m f ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_6 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappynumber d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappylerfu_string d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_6 e1 =
      case testPappyNUhA_clause d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappymex_operator d5 of
                Parsed m d7 e7 ->
                  Parsed ( NUhA n f m ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_7 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_7 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappySE_clause d of
        Parsed s d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappytanru_unit_2 d5 of
                Parsed t d7 e7 ->
                  Parsed ( SE s f t ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_8 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_8 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 =
      case pappyResult3 of
        Parsed j d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case pappyResult7 of
                Parsed t d7 e7 ->
                  case testPappytanru_unit_2 d7 of
                    Parsed tu d9 e9 ->
                      Parsed ( JAI j f t tu ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_9 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_9 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappytag d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_9 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
      where
        pappyResult3 =
          case testPappyJAI_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_9 e1 =
      case testPappyNAhE_clause d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappytanru_unit_2 d5 of
                Parsed t d7 e7 ->
                  Parsed ( NAhE n f t ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_10 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_10 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_10 (max e3 e1)
    pappyAlt1_10 e1 =
      case testPappyNU_clause d of
        Parsed nu d3 e3 ->
          case pappyResult5 of
            Parsed nai d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  case testPappyStarRule104 d7 of
                    Parsed j d9 e9 ->
                      case testPappysubsentence d9 of
                        Parsed s d11 e11 ->
                          case pappyResult13 of
                            Parsed k d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed g d15 e15 ->
                                  Parsed ( NU nu nai f j s k g ) d15 (maximum [e15,e13,e11,e9,e7,e5,e3,e1])
                                NoParse e15 -> pappyAlt1_11 (maximum [e15,e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_11 (maximum [e13,e11,e9,e7,e5,e3,e1])
                          where
                            pappyResult13 =
                              case pappyResult15 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                              where
                                pappyResult15 =
                                  case testPappyKEI_pre d11 of
                                    Parsed p d17 e17 ->
                                      case testPappypost_clause d17 of
                                        Parsed q d19 e19 ->
                                          Parsed ( (fst p, snd p, q) ) d19 (max e19 e17)
                                        NoParse e19 -> NoParse (max e19 e17)
                                    NoParse e17 -> NoParse e17
                        NoParse e11 -> pappyAlt1_11 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_11 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_11 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_11 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyNAI_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_11 (max e3 e1)
    pappyAlt1_11 e1 = NoParse e1

testPappyParseStarRule107 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule107 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule107 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 testPappyBE_clause d of
            Parsed _ d5 e5 ->
              case testPappyStarRule110 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappylinkargs_1 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappylinkargs :: TestPappyDerivs -> Result TestPappyDerivs (Linkargs)
testPappylinkargs d =
  case testPappyStarRule107 d of
    Parsed _ d1 e1 ->
      case testPappylinkargs_1 d1 of
        Parsed l d3 e3 ->
          Parsed ( l ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParselinkargs_1 :: TestPappyDerivs -> Result TestPappyDerivs (Linkargs)
testPappyParselinkargs_1 d =
  case testPappyBE_clause d of
    Parsed be d1 e1 ->
      case testPappyStarRule188 d1 of
        Parsed f d3 e3 ->
          case testPappyterm d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed l d7 e7 ->
                  case pappyResult9 of
                    Parsed beho d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( BE be f t l beho g ) d11 (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])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case testPappyBEhO_pre d7 of
                            Parsed p d13 e13 ->
                              case testPappypost_clause d13 of
                                Parsed q d15 e15 ->
                                  Parsed ( (fst p, snd p, q) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappylinks d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule110 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule110 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule110 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
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case pappyResult13 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                          where
                            pappyResult13 =
                              case testPappyBE_clause d11 of
                                Parsed _ d15 e15 ->
                                  Parsed ( () ) d15 e15
                                NoParse e15 -> NoParse e15
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappyBE_clause d of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule111 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule111 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule111 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 testPappyBEI_clause d of
            Parsed _ d5 e5 ->
              case testPappyStarRule113 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappylinks_1 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappylinks :: TestPappyDerivs -> Result TestPappyDerivs (Links)
testPappylinks d =
  case testPappyStarRule111 d of
    Parsed _ d1 e1 ->
      case testPappylinks_1 d1 of
        Parsed l d3 e3 ->
          Parsed ( l ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParselinks_1 :: TestPappyDerivs -> Result TestPappyDerivs (Links)
testPappyParselinks_1 d =
  case testPappyBEI_clause d of
    Parsed b d1 e1 ->
      case testPappyStarRule188 d1 of
        Parsed f d3 e3 ->
          case testPappyterm d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed l d7 e7 ->
                  Parsed ( BEI b f t l ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappylinks d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule113 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule113 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule113 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
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case pappyResult13 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                          where
                            pappyResult13 =
                              case testPappyBEI_clause d11 of
                                Parsed _ d15 e15 ->
                                  Parsed ( () ) d15 e15
                                NoParse e15 -> NoParse e15
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
          where
            pappyResult5 =
              case testPappyBEI_clause d of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsequantifier :: TestPappyDerivs -> Result TestPappyDerivs (Quantifier)
testPappyParsequantifier d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappynumber d of
        Parsed n d3 e3 ->
          case testPappyMOI_clause d3 of
            NoParse e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      Parsed ( Number n b f ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyBOI_clause d3 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d3 e9
            Parsed _ _ e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyVEI_clause d of
        Parsed vei d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappymex d5 of
                Parsed m d7 e7 ->
                  case pappyResult9 of
                    Parsed veho d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( VEI  vei f m veho g ) 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])
                  where
                    pappyResult9 =
                      case testPappyVEhO_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                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

testPappyParseStarRule117 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule117 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule117 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 testPappymex_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule119 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappymex_0 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappymex :: TestPappyDerivs -> Result TestPappyDerivs (Mex)
testPappymex d =
  case testPappyStarRule117 d of
    Parsed _ d1 e1 ->
      case testPappymex_0 d1 of
        Parsed m0 d3 e3 ->
          Parsed ( m0 ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule118 :: TestPappyDerivs -> Result TestPappyDerivs ([ (MexOperator, Mex) ])
testPappyParseStarRule118 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule118 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 testPappyoperator d of
            Parsed o d5 e5 ->
              case testPappymex_1 d5 of
                Parsed m d7 e7 ->
                  Parsed ( (o, m) ) 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

testPappyParsemex_0 :: TestPappyDerivs -> Result TestPappyDerivs (Mex)
testPappyParsemex_0 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappymex_1 d of
        Parsed m d3 e3 ->
          case testPappyStarRule118 d3 of
            Parsed oms d5 e5 ->
              Parsed ( if null oms then m else MexOperatorMex m oms ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyFUhA_clause d of
        Parsed fuha d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyrp_expression d5 of
                Parsed r d7 e7 ->
                  Parsed ( FUhA fuha f r ) d7 (maximum [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

testPappyParseStarRule119 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule119 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule119 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 testPappymex_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappymex_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsemex_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParsemex_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyFUhA_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyPEhO_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyoperand_start d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParsemex_1 :: TestPappyDerivs -> Result TestPappyDerivs (Mex)
testPappyParsemex_1 d =
  case testPappymex_2 d of
    Parsed m2 d1 e1 ->
      case pappyResult3 of
        Parsed bfom d3 e3 ->
          Parsed ( maybe m2 (\(b, f, o, m1) -> BIhE m2 b f o m1) bfom ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappyoperator d9 of
                        Parsed o d11 e11 ->
                          case testPappymex_1 d11 of
                            Parsed m d13 e13 ->
                              Parsed ( (b, f, o, m) ) d13 (maximum [e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
              where
                pappyResult7 =
                  case testPappyBIhE_pre d1 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
    NoParse e1 -> NoParse e1

testPappyParsemex_2 :: TestPappyDerivs -> Result TestPappyDerivs (Mex)
testPappyParsemex_2 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyoperand d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed p d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyoperator d5 of
                Parsed o d7 e7 ->
                  case testPappyPlusRule7 d7 of
                    Parsed fo d9 e9 ->
                      case pappyResult11 of
                        Parsed k d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed g d13 e13 ->
                              Parsed ( PEhO p f o fo k g ) d13 (maximum [e13,e11,e9,e7,e5,e3,e1])
                            NoParse e13 -> pappyAlt1_3 (maximum [e13,e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_3 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                          where
                            pappyResult13 =
                              case testPappyKUhE_pre d9 of
                                Parsed p d15 e15 ->
                                  case testPappypost_clause d15 of
                                    Parsed q d17 e17 ->
                                      Parsed ( (fst p, snd p, q) ) d17 (max e17 e15)
                                    NoParse e17 -> NoParse (max e17 e15)
                                NoParse e15 -> NoParse e15
                    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)
      where
        pappyResult3 =
          case testPappyPEhO_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 = NoParse e1

testPappyrp_expression :: TestPappyDerivs -> Result TestPappyDerivs (RPExpression)
testPappyrp_expression d =
  case testPappyoperand d of
    Parsed o d1 e1 ->
      case testPappyrp_expression_tail d1 of
        Parsed rt d3 e3 ->
          Parsed ( RPExpression o rt ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParserp_expression_tail :: TestPappyDerivs -> Result TestPappyDerivs ( Maybe RPExpressionTail)
testPappyParserp_expression_tail d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyrp_expression d of
        Parsed r d3 e3 ->
          case testPappyoperator d3 of
            Parsed o d5 e5 ->
              case testPappyrp_expression_tail d5 of
                Parsed rt d7 e7 ->
                  Parsed ( Just (RPExpressionTail r o rt) ) d7 (maximum [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 =
      Parsed ( Nothing ) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule124 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule124 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule124 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 testPappyoperator_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule128 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappyoperator_0 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyoperator :: TestPappyDerivs -> Result TestPappyDerivs (MexOperator)
testPappyoperator d =
  case testPappyStarRule124 d of
    Parsed _ d1 e1 ->
      case testPappyoperator_0 d1 of
        Parsed o0 d3 e3 ->
          Parsed ( o0 ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule125 :: TestPappyDerivs -> Result TestPappyDerivs ([ Either (JoikJek, [Free], MexOperator) (Joik, Maybe Tag, Clause, [Free], MexOperator, Maybe Clause, [Free]) ])
testPappyParseStarRule125 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule125 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyjoik_jek d of
                Parsed jf d7 e7 ->
                  case testPappyoperator_1 d7 of
                    Parsed o1 d9 e9 ->
                      Parsed ( Left (fst jf, snd jf, o1) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyjoik d of
                Parsed j d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyKE_clause d9 of
                        Parsed ke d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappyoperator d13 of
                                Parsed o d15 e15 ->
                                  case pappyResult17 of
                                    Parsed kehe d17 e17 ->
                                      case testPappyStarRule188 d17 of
                                        Parsed g d19 e19 ->
                                          Parsed ( Right (j, t, ke, f, o, kehe, g) ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                        NoParse e19 -> pappyAlt5_3 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                    NoParse e17 -> pappyAlt5_3 (maximum [e17,e15,e13,e11,e9,e7,e5])
                                  where
                                    pappyResult17 =
                                      case testPappyKEhE_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> pappyAlt5_3 (maximum [e15,e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyoperator_0 :: TestPappyDerivs -> Result TestPappyDerivs (MexOperator)
testPappyoperator_0 d =
  case testPappyoperator_1 d of
    Parsed o1 d1 e1 ->
      case testPappyStarRule125 d1 of
        Parsed j d3 e3 ->
          Parsed ( JoikJekJoikKEOperator o1 j ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule128 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule128 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule128 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 testPappyoperator_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyoperator_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseoperator_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParseoperator_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyguhek d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyKE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyNAhE_clause d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyMAhO_clause d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_5 e1 =
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyVUhU_clause d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_6 e1 = NoParse e1

testPappyParseoperator_1 :: TestPappyDerivs -> Result TestPappyDerivs (MexOperator)
testPappyParseoperator_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyoperator_2 d of
        Parsed o2 d3 e3 ->
          case pappyResult5 of
            Parsed jtbfo1 d5 e5 ->
              Parsed ( maybe o2 (\(j, t, b, f, o1) -> JekJoikBOOperator o2 j t b f o1) jtbfo1 ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed j d9 e9 ->
                      case pappyResult11 of
                        Parsed t d11 e11 ->
                          case testPappyBO_clause d11 of
                            Parsed b d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed f d15 e15 ->
                                  case testPappyoperator_1 d15 of
                                    Parsed o1 d17 e17 ->
                                      Parsed ( (j, t, b, f, o1) ) d17 (maximum [e17,e15,e13,e11,e9])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9])
                        NoParse e11 -> NoParse (max e11 e9)
                      where
                        pappyResult11 =
                          case testPappystag d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> NoParse e9
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (testPappyPos d3) []) where
                        pappyAlt11_1 e11 =
                          case testPappyjek d3 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_2 (max e13 e11)
                        pappyAlt11_2 e11 =
                          case testPappyjoik d3 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_3 (max e13 e11)
                        pappyAlt11_3 e11 = NoParse e11
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyguhek d of
        Parsed guhek d3 e3 ->
          case testPappyoperator_1 d3 of
            Parsed o1 d5 e5 ->
              case testPappygik d5 of
                Parsed gik d7 e7 ->
                  case testPappyoperator_2 d7 of
                    Parsed o2 d9 e9 ->
                      Parsed ( GuhekOperator guhek o1 gik o2 ) d9 (maximum [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

testPappyParseoperator_2 :: TestPappyDerivs -> Result TestPappyDerivs (MexOperator)
testPappyParseoperator_2 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappymex_operator d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyKE_clause d of
        Parsed ke d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyoperator d5 of
                Parsed o d7 e7 ->
                  case pappyResult9 of
                    Parsed kehe d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( KEOperator ke f o kehe g ) 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])
                  where
                    pappyResult9 =
                      case testPappyKEhE_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                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

testPappyParsemex_operator :: TestPappyDerivs -> Result TestPappyDerivs (MexOperator)
testPappyParsemex_operator d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappySE_clause d of
        Parsed s d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappymex_operator d5 of
                Parsed m d7 e7 ->
                  Parsed ( SEOperator s f m ) d7 (maximum [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 testPappyNAhE_clause d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappymex_operator d5 of
                Parsed m d7 e7 ->
                  Parsed ( NAhEOperator n f m ) d7 (maximum [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 =
      case testPappyMAhO_clause d of
        Parsed maho d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappymex d5 of
                Parsed m d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( MAhO maho f m t g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_4 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyTEhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyselbri d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( NAhU n f s t g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_5 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyTEhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAhU_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_5 e1 =
      case testPappyVUhU_clause d of
        Parsed v d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( VUhU v f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 = NoParse e1

testPappyParseStarRule139 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule139 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule139 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 testPappyoperand_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule142 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappyoperand_0 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyoperand :: TestPappyDerivs -> Result TestPappyDerivs (Operand)
testPappyoperand d =
  case testPappyStarRule139 d of
    Parsed _ d1 e1 ->
      case testPappyoperand_0 d1 of
        Parsed o0 d3 e3 ->
          Parsed ( o0 ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseoperand_0 :: TestPappyDerivs -> Result TestPappyDerivs (Operand)
testPappyParseoperand_0 d =
  case pappyResult1 of
    Parsed o1 d1 e1 ->
      case pappyResult3 of
        Parsed jftkefokeheg d3 e3 ->
          Parsed ( maybe o1 (\(j, f, t, ke, g, o, kehe, h) -> OperandJoikEkKE o1 j f t ke g o kehe h) jftkefokeheg ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyjoik_ek d1 of
                Parsed jf d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyKE_clause d9 of
                        Parsed ke d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappyoperand d13 of
                                Parsed o d15 e15 ->
                                  case pappyResult17 of
                                    Parsed kehe d17 e17 ->
                                      case testPappyStarRule188 d17 of
                                        Parsed g d19 e19 ->
                                          Parsed ( (fst jf, snd jf, t, ke, f, o, kehe, g) ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e15,e13,e11,e9,e7])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7])
                                  where
                                    pappyResult17 =
                                      case testPappyKEhE_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyoperand_2 d of
        Parsed o2 d3 e3 ->
          case testPappyStarRule143 d3 of
            Parsed jeo2 d5 e5 ->
              Parsed ( if null jeo2 then o2 else OperandJoikEk o2 jeo2 ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParseStarRule142 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule142 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule142 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 testPappyoperand_start d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyoperand_start d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseoperand_start :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParseoperand_start d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyquantifier d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappylerfu_word d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyNIhE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyMOhE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyJOhI_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappygek d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappyLAhE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 =
      case testPappyNAhE_clause d of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_9 (max e3 e1)
    pappyAlt1_9 e1 = NoParse e1

testPappyParseStarRule143 :: TestPappyDerivs -> Result TestPappyDerivs ([ (JoikEk, [Free], Operand) ])
testPappyParseStarRule143 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule143 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 testPappyjoik_ek d of
            Parsed j d5 e5 ->
              case testPappyoperand_2 d5 of
                Parsed o d7 e7 ->
                  Parsed ( (fst j, snd j, o) ) 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

testPappyParseoperand_2 :: TestPappyDerivs -> Result TestPappyDerivs (Operand)
testPappyParseoperand_2 d =
  case testPappyoperand_3 d of
    Parsed o3 d1 e1 ->
      case pappyResult3 of
        Parsed jtbfo d3 e3 ->
          Parsed ( maybe o3 (\(j, f, t, b, g, o2) -> OperandJoikEkBO o3 j f t b g o2) jtbfo ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyjoik_ek d1 of
                Parsed j d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyBO_clause d9 of
                        Parsed b d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case testPappyoperand_2 d13 of
                                Parsed o d15 e15 ->
                                  Parsed ( (fst j, snd j, t, b, f, o) ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> NoParse (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> NoParse (maximum [e13,e11,e9,e7])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7])
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappystag d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1

testPappyParsePlusRule7 :: TestPappyDerivs -> Result TestPappyDerivs ([Mex])
testPappyParsePlusRule7 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappymex_2 d of
        Parsed v d3 e3 ->
          case testPappyPlusRule7 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 testPappymex_2 d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseoperand_3 :: TestPappyDerivs -> Result TestPappyDerivs (Operand)
testPappyParseoperand_3 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyquantifier d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappylerfu_string d of
        Parsed l d3 e3 ->
          case testPappyMOI_clause d3 of
            NoParse e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      Parsed ( OLerfuString l b f ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyBOI_clause d3 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d3 e9
            Parsed _ _ e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyNIhE_clause d of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyselbri d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( NIhE n f s t g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_4 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyTEhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyMOhE_clause d of
        Parsed m d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappysumti d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( MOhE m f s t g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_5 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyTEhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyJOhI_clause d of
        Parsed j d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyPlusRule7 d5 of
                Parsed m d7 e7 ->
                  case pappyResult9 of
                    Parsed t d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( JOhI j f m t g ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_6 (maximum [e11,e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_6 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappyTEhU_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_6 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_6 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappygek d of
        Parsed gek d3 e3 ->
          case testPappyoperand d3 of
            Parsed o d5 e5 ->
              case testPappygik d5 of
                Parsed gik d7 e7 ->
                  case testPappyoperand_3 d7 of
                    Parsed o3 d9 e9 ->
                      Parsed ( GekOperand gek o gik o3 ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_7 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_7 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_7 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappyLAhE_NAhE d of
        Parsed lnbf d3 e3 ->
          case testPappyoperand d3 of
            Parsed o d5 e5 ->
              case pappyResult7 of
                Parsed l d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed g d9 e9 ->
                      Parsed ( let (ln, b, f) = lnbf in LAhE_NAhEOperand ln b f o l g ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_8 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_8 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyLUhU_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_8 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 = NoParse e1

testPappynumber :: TestPappyDerivs -> Result TestPappyDerivs (Number)
testPappynumber d =
  case testPappyPA_clause d of
    Parsed p d1 e1 ->
      case testPappyStarRule154 d1 of
        Parsed pls d3 e3 ->
          Parsed ( p : concat pls ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule154 :: TestPappyDerivs -> Result TestPappyDerivs ([ [Clause] ])
testPappyParseStarRule154 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule154 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyPA_clause d of
                Parsed p d7 e7 ->
                  Parsed ( [p] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappylerfu_word d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappylerfu_string :: TestPappyDerivs -> Result TestPappyDerivs (LerfuString)
testPappylerfu_string d =
  case testPappylerfu_word d of
    Parsed l d1 e1 ->
      case testPappyStarRule154 d1 of
        Parsed pls d3 e3 ->
          Parsed ( l ++ concat pls ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParselerfu_word :: TestPappyDerivs -> Result TestPappyDerivs ( [Clause] )
testPappyParselerfu_word d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed b d3 e3 ->
          Parsed ( [b] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyBY_pre d of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappypre_clause d of
                Parsed p d7 e7 ->
                  case testPappybu_clause_no_pre d7 of
                    Parsed b d9 e9 ->
                      Parsed ( (p, fst b, snd b) ) 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
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed lau d3 e3 ->
          case testPappylerfu_word d3 of
            Parsed l d5 e5 ->
              Parsed ( lau : l ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyLAU_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed tei d3 e3 ->
          case testPappylerfu_string d3 of
            Parsed l d5 e5 ->
              case pappyResult7 of
                Parsed f d7 e7 ->
                  Parsed ( tei : l ++ [f] ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyFOI_pre d5 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case testPappyTEI_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_4 e1 = NoParse e1

testPappyParseek :: TestPappyDerivs -> Result TestPappyDerivs (Ek)
testPappyParseek d =
  case pappyResult1 of
    Parsed na d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed a d5 e5 ->
              case pappyResult7 of
                Parsed nai d7 e7 ->
                  Parsed ( Ek na s a nai ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyA_pre d3 of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyNA_clause d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParseStarRule155 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule155 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule155 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 testPappygihek_1 d of
            Parsed _ d5 e5 ->
              case testPappyStarRule156 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappygihek d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappygihek :: TestPappyDerivs -> Result TestPappyDerivs (Gihek)
testPappygihek d =
  case testPappyStarRule155 d of
    Parsed _ d1 e1 ->
      case testPappygihek_1 d1 of
        Parsed g d3 e3 ->
          Parsed ( g ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParsegihek_1 :: TestPappyDerivs -> Result TestPappyDerivs (Gihek)
testPappyParsegihek_1 d =
  case pappyResult1 of
    Parsed na d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed g d5 e5 ->
              case pappyResult7 of
                Parsed nai d7 e7 ->
                  Parsed ( Gihek na s g nai ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyGIhA_pre d3 of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyNA_clause d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParseStarRule156 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule156 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule156 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 testPappygihek_1 d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappygihek_1 d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsejek :: TestPappyDerivs -> Result TestPappyDerivs (Jek)
testPappyParsejek d =
  case pappyResult1 of
    Parsed na d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          case testPappyJA_clause d3 of
            Parsed j d5 e5 ->
              case pappyResult7 of
                Parsed nai d7 e7 ->
                  Parsed ( Jek na s j nai ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyNA_clause d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParsejoik :: TestPappyDerivs -> Result TestPappyDerivs (Joik)
testPappyParsejoik d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed j d5 e5 ->
              case pappyResult7 of
                Parsed n d7 e7 ->
                  Parsed ( JOI s j n ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause 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])
          where
            pappyResult5 =
              case testPappyJOI_pre d3 of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_2 e1 =
      case testPappyinterval d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyGAhO_clause d of
        Parsed g1 d3 e3 ->
          case testPappyinterval d3 of
            Parsed i d5 e5 ->
              case testPappyGAhO_clause d5 of
                Parsed g2 d7 e7 ->
                  Parsed ( GAhO g1 i g2 ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseinterval :: TestPappyDerivs -> Result TestPappyDerivs (Joik)
testPappyParseinterval d =
  case pappyResult1 of
    Parsed s d1 e1 ->
      case pappyResult3 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed n d5 e5 ->
              Parsed ( BIhI s b n ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyNAI_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyBIhI_pre d1 of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappySE_clause d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParseStarRule157 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule157 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule157 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 testPappyjoik_ek_1 d of
            Parsed _ d5 e5 ->
              case testPappyStarRule160 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappyjoik_ek d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyjoik_ek :: TestPappyDerivs -> Result TestPappyDerivs ( (JoikEk, [Free]) )
testPappyjoik_ek d =
  case testPappyStarRule157 d of
    Parsed _ d1 e1 ->
      case testPappyjoik_ek_1 d1 of
        Parsed j d3 e3 ->
          Parsed ( j ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyjoik_ek_1 :: TestPappyDerivs -> Result TestPappyDerivs ( (JoikEk, [Free]) )
testPappyjoik_ek_1 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyjoik d of
        Parsed j d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (j, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyek d of
        Parsed e d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (e, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule160 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule160 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule160 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 testPappyjoik_ek_1 d of
            NoParse e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappypre_zei_bu d of
                        Parsed _ d11 e11 ->
                          Parsed ( () ) d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappySA_clause d of
                        Parsed _ d11 e11 ->
                          case testPappyjoik_ek_1 d11 of
                            NoParse e13 ->
                              Parsed ( () ) d11 (maximum [e13,e11,e9])
                            Parsed _ _ e13 -> pappyAlt9_3 (maximum [e13,e11,e9])
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyjoik_jek :: TestPappyDerivs -> Result TestPappyDerivs ( (JoikJek, [Free]) )
testPappyjoik_jek d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyjoik d of
        Parsed j d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (j, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyjek d of
        Parsed j d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (j, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsegek :: TestPappyDerivs -> Result TestPappyDerivs (Gek)
testPappyParsegek d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed g d5 e5 ->
              case pappyResult7 of
                Parsed n d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      Parsed ( GA s g n f ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause 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])
          where
            pappyResult5 =
              case testPappyGA_pre d3 of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case testPappySE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_2 e1 =
      case testPappyjoik d of
        Parsed j d3 e3 ->
          case testPappyGI_clause d3 of
            Parsed g d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( JoikGI j g f ) d7 (maximum [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 =
      case testPappystag d of
        Parsed s d3 e3 ->
          case testPappygik d3 of
            Parsed g d5 e5 ->
              Parsed ( STagGik s g ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseguhek :: TestPappyDerivs -> Result TestPappyDerivs (Guhek)
testPappyParseguhek d =
  case pappyResult1 of
    Parsed s d1 e1 ->
      case pappyResult3 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed n d5 e5 ->
              case testPappyStarRule188 d5 of
                Parsed f d7 e7 ->
                  Parsed ( (s, g, n, f) ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyNAI_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyGUhA_pre d1 of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappySE_clause d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappyParsegik :: TestPappyDerivs -> Result TestPappyDerivs (Gik)
testPappyParsegik d =
  case testPappyGI_clause d of
    Parsed g d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( (g, n, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAI_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappytag :: TestPappyDerivs -> Result TestPappyDerivs (Tag)
testPappytag d =
  case testPappytense_modal d of
    Parsed t1 d1 e1 ->
      case testPappyStarRule169 d1 of
        Parsed jt d3 e3 ->
          Parsed ( if null jt then t1 else JoikJekTag t1 jt ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule168 :: TestPappyDerivs -> Result TestPappyDerivs ([ (JoikJek, Tag) ])
testPappyParseStarRule168 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule168 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 j d5 e5 ->
              case testPappysimple_tense_modal d5 of
                Parsed s d7 e7 ->
                  Parsed ( (j, s) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappyjek d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyjoik d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule169 :: TestPappyDerivs -> Result TestPappyDerivs ([ (JoikJek, [Free], Tag) ])
testPappyParseStarRule169 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule169 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 testPappyjoik_jek d of
            Parsed jf d5 e5 ->
              case testPappytense_modal d5 of
                Parsed t d7 e7 ->
                  Parsed ( (fst jf, snd jf, t) ) 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

testPappystag :: TestPappyDerivs -> Result TestPappyDerivs (Tag)
testPappystag d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappysimple_tense_modal d of
        Parsed st d3 e3 ->
          case testPappyStarRule168 d3 of
            Parsed jst d5 e5 ->
              Parsed ( if null jst then st else JekJoikSTag st jst ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappytense_modal d of
        Parsed t d3 e3 ->
          case testPappyStarRule169 d3 of
            Parsed jt d5 e5 ->
              Parsed ( if null jt then t else JoikJekTag t jt ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsetense_modal :: TestPappyDerivs -> Result TestPappyDerivs (Tag)
testPappyParsetense_modal d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappysimple_tense_modal d of
        Parsed s d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              Parsed ( if null f then s else SimpleTenseModalFree s f ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed fiho d3 e3 ->
          case testPappyStarRule188 d3 of
            Parsed f d5 e5 ->
              case testPappyselbri d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed fehu d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed g d11 e11 ->
                          Parsed ( FIhO fiho f s fehu g ) 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])
                  where
                    pappyResult9 =
                      case pappyResult11 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                      where
                        pappyResult11 =
                          case testPappyFEhU_pre d7 of
                            Parsed p d13 e13 ->
                              case testPappypost_clause d13 of
                                Parsed q d15 e15 ->
                                  Parsed ( (fst p, snd p, q) ) d15 (max e15 e13)
                                NoParse e15 -> NoParse (max e15 e13)
                            NoParse e13 -> NoParse e13
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyFIhO_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_3 e1 = NoParse e1

testPappyParsesimple_tense_modal :: TestPappyDerivs -> Result TestPappyDerivs (Tag)
testPappyParsesimple_tense_modal d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed nahe d3 e3 ->
          case pappyResult5 of
            Parsed s d5 e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  case pappyResult9 of
                    Parsed nai d9 e9 ->
                      case pappyResult11 of
                        Parsed ki d11 e11 ->
                          Parsed ( BAI nahe s b nai ki ) d11 (maximum [e11,e9,e7,e5,e3,e1])
                        NoParse e11 -> pappyAlt1_2 (maximum [e11,e9,e7,e5,e3,e1])
                      where
                        pappyResult11 =
                          case testPappyKI_clause 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])
                  where
                    pappyResult9 =
                      case testPappyNAI_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyBAI_pre d5 of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappySE_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAhE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed tsc d5 e5 ->
              case pappyResult7 of
                Parsed k d7 e7 ->
                  Parsed ( if isNothing n && isNothing k then tsc else NAhETenseKI n tsc k ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyKI_clause d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (testPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case testPappytime_space d3 of
                    Parsed t d9 e9 ->
                      case testPappyCAhA_clause d9 of
                        Parsed c d11 e11 ->
                          Parsed ( TenseCAhA t c ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_2 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappytime_space d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 =
                  case testPappyCAhA_clause d3 of
                    Parsed c d9 e9 ->
                      Parsed ( CAhA c ) d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_4 (max e9 e7)
                pappyAlt7_4 e7 = NoParse e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAhE_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case testPappyKI_clause d of
        Parsed k d3 e3 ->
          Parsed ( KI k ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed c d3 e3 ->
          Parsed ( CUhE c ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          case testPappyCUhE_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_5 e1 = NoParse e1

testPappytime_space :: TestPappyDerivs -> Result TestPappyDerivs (Tense)
testPappytime_space d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappytime d of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed s d5 e5 ->
              Parsed ( maybe t (TimeSpace t) s ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspace d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyspace d of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed t d5 e5 ->
              Parsed ( maybe s (SpaceTime s) t ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappytime d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsePlusRule8 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, Maybe Clause, Maybe Clause) ])
testPappyParsePlusRule8 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappytime_offset d of
        Parsed v d3 e3 ->
          case testPappyPlusRule8 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 testPappytime_offset d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule177 :: TestPappyDerivs -> Result TestPappyDerivs ([IntervalProperty])
testPappyParseStarRule177 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyinterval_property d of
        Parsed v d3 e3 ->
          case testPappyStarRule177 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

testPappyParseStarRule178 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, Maybe Clause, Maybe Clause) ])
testPappyParseStarRule178 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappytime_offset d of
        Parsed v d3 e3 ->
          case testPappyStarRule178 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

testPappyParsePlusRule9 :: TestPappyDerivs -> Result TestPappyDerivs ([IntervalProperty])
testPappyParsePlusRule9 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyinterval_property d of
        Parsed v d3 e3 ->
          case testPappyPlusRule9 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 testPappyinterval_property d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsetime :: TestPappyDerivs -> Result TestPappyDerivs (Tense)
testPappyParsetime d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyZI_clause d of
        Parsed zi d3 e3 ->
          case testPappyStarRule178 d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed zeha d7 e7 ->
                  case testPappyStarRule177 d7 of
                    Parsed i d9 e9 ->
                      Parsed ( Time (Just zi) t zeha i ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyzeha_pu 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 pappyResult3 of
        Parsed zi d3 e3 ->
          case testPappyPlusRule8 d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed zeha d7 e7 ->
                  case testPappyStarRule177 d7 of
                    Parsed i d9 e9 ->
                      Parsed ( Time zi t zeha i ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyzeha_pu d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyZI_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed zi d3 e3 ->
          case testPappyStarRule178 d3 of
            Parsed t d5 e5 ->
              case testPappyzeha_pu d5 of
                Parsed zeha d7 e7 ->
                  case testPappyStarRule177 d7 of
                    Parsed i d9 e9 ->
                      Parsed ( Time zi t (Just zeha) i ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case testPappyZI_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed zi d3 e3 ->
          case testPappyStarRule178 d3 of
            Parsed t d5 e5 ->
              case pappyResult7 of
                Parsed zeha d7 e7 ->
                  case testPappyPlusRule9 d7 of
                    Parsed i d9 e9 ->
                      Parsed ( Time zi t zeha i ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyzeha_pu d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          case testPappyZI_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_5 e1 = NoParse e1

testPappyParsezeha_pu :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, Maybe (Clause, Maybe Clause)) )
testPappyParsezeha_pu d =
  case pappyResult1 of
    Parsed z d1 e1 ->
      case pappyResult3 of
        Parsed pn d3 e3 ->
          Parsed ( (z, pn) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPU_clause d1 of
                Parsed p d7 e7 ->
                  case pappyResult9 of
                    Parsed n d9 e9 ->
                      Parsed ( (p, n) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                  where
                    pappyResult9 =
                      case testPappyNAI_clause d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyZEhA_pre d of
        Parsed p d3 e3 ->
          case testPappypost_clause d3 of
            Parsed q d5 e5 ->
              Parsed ( (fst p, snd p, q) ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParsetime_offset :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, Maybe Clause, Maybe Clause) )
testPappyParsetime_offset d =
  case testPappyPU_clause d of
    Parsed p d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed z d5 e5 ->
              Parsed ( (p, n, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyZI_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAI_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyParsePlusRule10 :: TestPappyDerivs -> Result TestPappyDerivs ([SpaceOffset])
testPappyParsePlusRule10 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyspace_offset d of
        Parsed v d3 e3 ->
          case testPappyPlusRule10 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 testPappyspace_offset d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule181 :: TestPappyDerivs -> Result TestPappyDerivs ([SpaceOffset])
testPappyParseStarRule181 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyspace_offset d of
        Parsed v d3 e3 ->
          case testPappyStarRule181 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

testPappyParsespace :: TestPappyDerivs -> Result TestPappyDerivs (Tense)
testPappyParsespace d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyVA_clause d of
        Parsed v d3 e3 ->
          case testPappyStarRule181 d3 of
            Parsed so d5 e5 ->
              case pappyResult7 of
                Parsed si d7 e7 ->
                  case pappyResult9 of
                    Parsed m d9 e9 ->
                      Parsed ( Space (Just v) so si m ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_2 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappymohi_space_offset d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyspace_interval 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 pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyPlusRule10 d3 of
            Parsed so d5 e5 ->
              case pappyResult7 of
                Parsed si d7 e7 ->
                  case pappyResult9 of
                    Parsed m d9 e9 ->
                      Parsed ( Space v so si m ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_3 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappymohi_space_offset d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyspace_interval d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
      where
        pappyResult3 =
          case testPappyVA_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule181 d3 of
            Parsed so d5 e5 ->
              case testPappyspace_interval d5 of
                Parsed si d7 e7 ->
                  case pappyResult9 of
                    Parsed m d9 e9 ->
                      Parsed ( Space v so (Just si) m ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_4 (maximum [e9,e7,e5,e3,e1])
                  where
                    pappyResult9 =
                      case testPappymohi_space_offset d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case testPappyVA_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_4 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule181 d3 of
            Parsed so d5 e5 ->
              case pappyResult7 of
                Parsed si d7 e7 ->
                  case testPappymohi_space_offset d7 of
                    Parsed m d9 e9 ->
                      Parsed ( Space v so si (Just m) ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse e9 -> pappyAlt1_5 (maximum [e9,e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_5 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyspace_interval d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt1_5 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
      where
        pappyResult3 =
          case testPappyVA_clause d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_5 e1 = NoParse e1

testPappymohi_space_offset :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, SpaceOffset) )
testPappymohi_space_offset d =
  case pappyResult1 of
    Parsed m d1 e1 ->
      case testPappyspace_offset d1 of
        Parsed s d3 e3 ->
          Parsed ( (m, s) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyMOhI_pre d of
        Parsed p d3 e3 ->
          case testPappypost_clause d3 of
            Parsed q d5 e5 ->
              Parsed ( (fst p, snd p, q) ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParsespace_offset :: TestPappyDerivs -> Result TestPappyDerivs (SpaceOffset)
testPappyParsespace_offset d =
  case testPappyFAhA_clause d of
    Parsed f d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed v d5 e5 ->
              Parsed ( FAhA f n v ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyVA_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAI_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyParsespace_interval :: TestPappyDerivs -> Result TestPappyDerivs (SpaceInterval)
testPappyParsespace_interval d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyVEhA_VIhA d of
        Parsed vv d3 e3 ->
          case pappyResult5 of
            Parsed fn d5 e5 ->
              case pappyResult7 of
                Parsed s d7 e7 ->
                  Parsed ( maybe (uncurry VEhAVIhAFEhE vv s) (\(f, n) -> uncurry VEhAVIhAFAhAFEhE vv f n s) fn ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyPlusRule11 d5 of
                    Parsed s d9 e9 ->
                      Parsed ( FEhE s ) d9 e9
                    NoParse e9 -> NoParse e9
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyFAhA_NAI d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyVEhA_VIhA d of
        Parsed vv d3 e3 ->
          case pappyResult5 of
            Parsed fn d5 e5 ->
              Parsed ( maybe (uncurry VEhAVIhA vv) (\(f, n) -> uncurry VEhAVIhAFAhA vv f n) fn ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyFAhA_NAI d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyPlusRule11 d of
        Parsed s d3 e3 ->
          Parsed ( FEhE s ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseVEhA_VIhA :: TestPappyDerivs -> Result TestPappyDerivs ( (Maybe Clause, Maybe Clause) )
testPappyParseVEhA_VIhA d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyVEhA_clause d of
        Parsed veha d3 e3 ->
          case testPappyVIhA_clause d3 of
            NoParse e5 ->
              Parsed ( (Just veha, Nothing) ) d3 (maximum [e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyVIhA_clause d of
        Parsed viha d3 e3 ->
          Parsed ( (Nothing, Just viha) ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyVEhA_clause d of
        Parsed veha d3 e3 ->
          case testPappyVIhA_clause d3 of
            Parsed viha d5 e5 ->
              Parsed ( (Just veha, Just viha) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyFAhA_NAI :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, Maybe Clause) )
testPappyFAhA_NAI d =
  case testPappyFAhA_clause d of
    Parsed f d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          Parsed ( (f, n) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAI_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyParsePlusRule11 :: TestPappyDerivs -> Result TestPappyDerivs ([ (Clause, IntervalProperty) ])
testPappyParsePlusRule11 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyspace_int_prop d of
        Parsed v d3 e3 ->
          case testPappyPlusRule11 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 testPappyspace_int_prop d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyspace_int_prop :: TestPappyDerivs -> Result TestPappyDerivs ( (Clause, IntervalProperty) )
testPappyspace_int_prop d =
  case pappyResult1 of
    Parsed f d1 e1 ->
      case testPappyinterval_property d1 of
        Parsed ip d3 e3 ->
          Parsed ( (f, ip) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyFEhE_pre d of
        Parsed p d3 e3 ->
          case testPappypost_clause d3 of
            Parsed q d5 e5 ->
              Parsed ( (fst p, snd p, q) ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParseinterval_property :: TestPappyDerivs -> Result TestPappyDerivs (IntervalProperty)
testPappyParseinterval_property d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappynumber d of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed r d5 e5 ->
              case pappyResult7 of
                Parsed nai d7 e7 ->
                  Parsed ( ROI n r nai ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyNAI_clause 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])
          where
            pappyResult5 =
              case testPappyROI_pre d3 of
                Parsed p d7 e7 ->
                  case testPappypost_clause d7 of
                    Parsed q d9 e9 ->
                      Parsed ( (fst p, snd p, q) ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case pappyResult3 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed n d5 e5 ->
              Parsed ( TAhE t n ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyNAI_clause 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 testPappyTAhE_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_3 e1 =
      case pappyResult3 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed n d5 e5 ->
              Parsed ( ZAhO z n ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_4 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyNAI_clause d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
      where
        pappyResult3 =
          case testPappyZAhO_pre d of
            Parsed p d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (fst p, snd p, q) ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_4 e1 = NoParse e1

testPappyParsePlusRule12 :: TestPappyDerivs -> Result TestPappyDerivs ([Clause])
testPappyParsePlusRule12 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyCMENE_clause d of
        Parsed v d3 e3 ->
          case testPappyPlusRule12 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 testPappyCMENE_clause d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule188 :: TestPappyDerivs -> Result TestPappyDerivs ([Free])
testPappyParseStarRule188 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule188 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case pappyResult7 of
                Parsed sei d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case pappyResult11 of
                        Parsed t d11 e11 ->
                          case testPappyselbri d11 of
                            Parsed s d13 e13 ->
                              case pappyResult15 of
                                Parsed sehu d15 e15 ->
                                  Parsed ( SEI sei f t s sehu ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> pappyAlt5_2 (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case testPappySEhU_clause d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                          where
                            pappyResult13 =
                              case testPappyPlusRule3 d9 of
                                Parsed t d15 e15 ->
                                  case pappyResult17 of
                                    Parsed c d17 e17 ->
                                      case testPappyStarRule188 d17 of
                                        Parsed f d19 e19 ->
                                          Parsed ( (t, c, f) ) d19 (maximum [e19,e17,e15])
                                        NoParse e19 -> NoParse (maximum [e19,e17,e15])
                                    NoParse e17 -> NoParse (max e17 e15)
                                  where
                                    pappyResult17 =
                                      case testPappyCU_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> NoParse e15
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
              where
                pappyResult7 =
                  case testPappySEI_pre d of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
            pappyAlt5_2 e5 =
              case pappyResult7 of
                Parsed soi d7 e7 ->
                  case testPappyStarRule188 d7 of
                    Parsed f d9 e9 ->
                      case testPappysumti d9 of
                        Parsed s d11 e11 ->
                          case pappyResult13 of
                            Parsed t d13 e13 ->
                              case pappyResult15 of
                                Parsed sehu d15 e15 ->
                                  Parsed ( SOI soi f s t sehu ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> pappyAlt5_3 (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case testPappySEhU_clause d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                          where
                            pappyResult13 =
                              case testPappysumti d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
              where
                pappyResult7 =
                  case testPappySOI_pre d of
                    Parsed p d9 e9 ->
                      case testPappypost_clause d9 of
                        Parsed q d11 e11 ->
                          Parsed ( (fst p, snd p, q) ) d11 (max e11 e9)
                        NoParse e11 -> NoParse (max e11 e9)
                    NoParse e9 -> NoParse e9
            pappyAlt5_3 e5 =
              case testPappyvocative d of
                Parsed v d7 e7 ->
                  case pappyResult9 of
                    Parsed r1 d9 e9 ->
                      case testPappyselbri d9 of
                        Parsed s d11 e11 ->
                          case pappyResult13 of
                            Parsed r2 d13 e13 ->
                              case pappyResult15 of
                                Parsed d d15 e15 ->
                                  Parsed ( VocativeSelbri v r1 s r2 d ) d15 (maximum [e15,e13,e11,e9,e7,e5])
                                NoParse e15 -> pappyAlt5_4 (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case testPappyDOhU_clause d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                          where
                            pappyResult13 =
                              case testPappyrelative_clauses d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappyrelative_clauses d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyvocative d of
                Parsed v d7 e7 ->
                  case pappyResult9 of
                    Parsed r1 d9 e9 ->
                      case testPappyPlusRule12 d9 of
                        Parsed c d11 e11 ->
                          case testPappyStarRule188 d11 of
                            Parsed f d13 e13 ->
                              case pappyResult15 of
                                Parsed r2 d15 e15 ->
                                  case pappyResult17 of
                                    Parsed d d17 e17 ->
                                      Parsed ( VocativeCmene v r1 c f r2 d ) d17 (maximum [e17,e15,e13,e11,e9,e7,e5])
                                    NoParse e17 -> pappyAlt5_5 (maximum [e17,e15,e13,e11,e9,e7,e5])
                                  where
                                    pappyResult17 =
                                      case testPappyDOhU_clause d15 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                NoParse e15 -> pappyAlt5_5 (maximum [e15,e13,e11,e9,e7,e5])
                              where
                                pappyResult15 =
                                  case testPappyrelative_clauses d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappyrelative_clauses d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyvocative d of
                Parsed v d7 e7 ->
                  case pappyResult9 of
                    Parsed s d9 e9 ->
                      case pappyResult11 of
                        Parsed d d11 e11 ->
                          Parsed ( VocativeSumti v s d ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case testPappyDOhU_clause d9 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappysumti d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case pappyResult7 of
                Parsed nl d7 e7 ->
                  case pappyResult9 of
                    Parsed m d9 e9 ->
                      Parsed ( MAI nl m ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_7 (maximum [e9,e7,e5])
                  where
                    pappyResult9 =
                      case testPappyMAI_pre d7 of
                        Parsed p d11 e11 ->
                          case testPappypost_clause d11 of
                            Parsed q d13 e13 ->
                              Parsed ( (fst p, snd p, q) ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
                NoParse e7 -> pappyAlt5_7 (max e7 e5)
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappynumber d of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappylerfu_string d of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_3 (max e11 e9)
                    pappyAlt9_3 e9 = NoParse e9
            pappyAlt5_7 e5 =
              case testPappyTO_clause d of
                Parsed to d7 e7 ->
                  case testPappytext d7 of
                    Parsed t d9 e9 ->
                      case pappyResult11 of
                        Parsed toi d11 e11 ->
                          Parsed ( TO to t toi ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                      where
                        pappyResult11 =
                          case pappyResult13 of
                            Parsed v13 d13 e13 -> Parsed (Just v13) d13 e13
                            NoParse e13 -> Parsed (Nothing) d9 e13
                          where
                            pappyResult13 =
                              case testPappyTOI_pre d9 of
                                Parsed p d15 e15 ->
                                  case testPappypost_clause d15 of
                                    Parsed q d17 e17 ->
                                      Parsed ( (fst p, snd p, q) ) d17 (max e17 e15)
                                    NoParse e17 -> NoParse (max e17 e15)
                                NoParse e15 -> NoParse e15
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              pappyAlt7_1 e5 where
                pappyAlt7_1 e7 =
                  case testPappyXI_clause d of
                    Parsed x d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          case pappyResult13 of
                            Parsed n d13 e13 ->
                              case pappyResult15 of
                                Parsed b d15 e15 ->
                                  Parsed ( XINumber x f n b ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_2 (maximum [e15,e13,e11,e9,e7])
                              where
                                pappyResult15 =
                                  case testPappyBOI_clause d13 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d13 e17
                            NoParse e13 -> pappyAlt7_2 (maximum [e13,e11,e9,e7])
                          where
                            pappyResult13 =
                              pappyAlt15_1 (ParseError (testPappyPos d11) []) where
                                pappyAlt15_1 e15 =
                                  case testPappynumber d11 of
                                    Parsed v17 d17 e17 -> Parsed v17 d17 (max e17 e15)
                                    NoParse e17 -> pappyAlt15_2 (max e17 e15)
                                pappyAlt15_2 e15 =
                                  case testPappylerfu_string d11 of
                                    Parsed v17 d17 e17 -> Parsed v17 d17 (max e17 e15)
                                    NoParse e17 -> pappyAlt15_3 (max e17 e15)
                                pappyAlt15_3 e15 = NoParse e15
                        NoParse e11 -> pappyAlt7_2 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyXI_clause d of
                    Parsed x d9 e9 ->
                      case testPappyStarRule188 d9 of
                        Parsed f d11 e11 ->
                          case testPappyVEI_clause d11 of
                            Parsed vei d13 e13 ->
                              case testPappyStarRule188 d13 of
                                Parsed g d15 e15 ->
                                  case testPappymex d15 of
                                    Parsed m d17 e17 ->
                                      case pappyResult19 of
                                        Parsed veho d19 e19 ->
                                          Parsed ( XIMex x f vei g m veho ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7])
                                        NoParse e19 -> pappyAlt7_3 (maximum [e19,e17,e15,e13,e11,e9,e7])
                                      where
                                        pappyResult19 =
                                          case testPappyVEhO_clause d17 of
                                            Parsed v21 d21 e21 -> Parsed (Just v21) d21 e21
                                            NoParse e21 -> Parsed (Nothing) d17 e21
                                    NoParse e17 -> pappyAlt7_3 (maximum [e17,e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_3 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_3 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_3 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = pappyAlt5_9 e7
            pappyAlt5_9 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsePlusRule13 :: TestPappyDerivs -> Result TestPappyDerivs ([ [([String], String, Indicators)] ])
testPappyParsePlusRule13 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappycoi_nai d of
        Parsed v d3 e3 ->
          case testPappyPlusRule13 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 testPappycoi_nai d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseStarRule189 :: TestPappyDerivs -> Result TestPappyDerivs ([ [([String], String, Indicators)] ])
testPappyParseStarRule189 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappycoi_nai d of
        Parsed v d3 e3 ->
          case testPappyStarRule189 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

testPappyParsevocative :: TestPappyDerivs -> Result TestPappyDerivs ( [([String], String, Indicators)] )
testPappyParsevocative d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyPlusRule13 d of
        Parsed cns d3 e3 ->
          case testPappyDOI_clause d3 of
            Parsed d d5 e5 ->
              Parsed ( concat cns ++ [d] ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappycoi_nai d of
        Parsed cn d3 e3 ->
          case testPappyStarRule189 d3 of
            Parsed cns d5 e5 ->
              Parsed ( cn ++ concat cns ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyDOI_clause d of
        Parsed d d3 e3 ->
          Parsed ( [d] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParsecoi_nai :: TestPappyDerivs -> Result TestPappyDerivs ( [([String], String, Indicators)] )
testPappyParsecoi_nai d =
  case pappyResult1 of
    Parsed c d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          Parsed ( c : ml n ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyNAI_clause d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyCOI_pre d of
        Parsed p d3 e3 ->
          case testPappypost_clause d3 of
            Parsed q d5 e5 ->
              Parsed ( (fst p, snd p, q) ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParsePlusRule14 :: TestPappyDerivs -> Result TestPappyDerivs ([ [([String], String)] ])
testPappyParsePlusRule14 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyindicator d of
        Parsed v d3 e3 ->
          case testPappyPlusRule14 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 testPappyindicator d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyindicators :: TestPappyDerivs -> Result TestPappyDerivs ( [([String], String)] )
testPappyindicators d =
  case pappyResult1 of
    Parsed f d1 e1 ->
      case testPappyPlusRule14 d1 of
        Parsed is d3 e3 ->
          Parsed ( ml f ++ concat is ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3
      where
        pappyResult3 =
          case testPappyFUhE_pre d of
            Parsed pre d5 e5 ->
              case testPappypost_clause_no_ind d5 of
                Parsed _ d7 e7 ->
                  Parsed ( pre ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5

testPappyParseindicator :: TestPappyDerivs -> Result TestPappyDerivs ( [([String], String)] )
testPappyParseindicator d =
  case pappyResult1 of
    Parsed i d1 e1 ->
      case testPappyBU_pre d1 of
        NoParse e3 ->
          Parsed ( i ) d1 (max e3 e1)
        Parsed _ _ e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case pappyResult5 of
            Parsed uc d5 e5 ->
              case pappyResult7 of
                Parsed n d7 e7 ->
                  Parsed ( uc : ml n ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_2 (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 =
                      case testPappyNAI_pre d5 of
                        Parsed p d11 e11 ->
                          case testPappypost_clause_no_ind d11 of
                            Parsed _ d13 e13 ->
                              Parsed ( p ) d13 (max e13 e11)
                            NoParse e13 -> NoParse (max e13 e11)
                        NoParse e11 -> NoParse e11
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappyUI_pre d of
                    Parsed pre d9 e9 ->
                      case testPappypost_clause_no_ind d9 of
                        Parsed _ d11 e11 ->
                          Parsed ( pre ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_2 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyCAI_pre d of
                    Parsed pre d9 e9 ->
                      case testPappypost_clause_no_ind d9 of
                        Parsed _ d11 e11 ->
                          Parsed ( pre ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_3 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 = NoParse e7
        pappyAlt3_2 e3 =
          case pappyResult5 of
            Parsed d d5 e5 ->
              Parsed ( d : [] ) d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
          where
            pappyResult5 =
              case testPappyDAhO_pre d of
                Parsed pre d7 e7 ->
                  case testPappypost_clause_no_ind d7 of
                    Parsed _ d9 e9 ->
                      Parsed ( pre ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        pappyAlt3_3 e3 =
          case pappyResult5 of
            Parsed f d5 e5 ->
              Parsed ( f : [] ) d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
          where
            pappyResult5 =
              case testPappyFUhO_pre d of
                Parsed pre d7 e7 ->
                  case testPappypost_clause_no_ind d7 of
                    Parsed post d9 e9 ->
                      Parsed ( pre ) d9 (max e9 e7)
                    NoParse e9 -> NoParse (max e9 e7)
                NoParse e7 -> NoParse e7
        pappyAlt3_4 e3 = NoParse e3

testPappyParseStarRule190 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule190 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule190 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 z d5 e5 ->
              case pappyResult7 of
                Parsed b d7 e7 ->
                  Parsed ( concatMap (" zei " ++) (fromMaybe [] z) ++ concat (replicate b " bu") ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  case testPappyPlusRule16 d5 of
                    Parsed b d9 e9 ->
                      Parsed ( length b ) d9 e9
                    NoParse e9 -> NoParse e9
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
              where
                pappyResult7 =
                  case testPappyPlusRule15 d of
                    Parsed ws d9 e9 ->
                      Parsed ( ws ) d9 e9
                    NoParse e9 -> NoParse e9
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyzei_clause_no_pre :: TestPappyDerivs -> Result TestPappyDerivs ( (String, Indicators) )
testPappyzei_clause_no_pre d =
  case testPappypre_zei_bu d of
    Parsed p d1 e1 ->
      case testPappyStarRule190 d1 of
        Parsed zb d3 e3 ->
          case pappyResult5 of
            Parsed z d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (p ++ concat zb ++ concatMap (" zei " ++) z, q) ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyPlusRule15 d3 of
                Parsed ws d7 e7 ->
                  Parsed ( ws ) d7 e7
                NoParse e7 -> NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule191 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule191 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule191 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 b d5 e5 ->
              case pappyResult7 of
                Parsed z d7 e7 ->
                  Parsed ( concat (replicate (fromMaybe 0 b) " bu") ++ concatMap (" zei " ++) z ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  case testPappyPlusRule15 d5 of
                    Parsed ws d9 e9 ->
                      Parsed ( ws ) d9 e9
                    NoParse e9 -> NoParse e9
            NoParse e5 -> NoParse e5
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
              where
                pappyResult7 =
                  case testPappyPlusRule16 d of
                    Parsed b d9 e9 ->
                      Parsed ( length b ) d9 e9
                    NoParse e9 -> NoParse e9
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappybu_clause_no_pre :: TestPappyDerivs -> Result TestPappyDerivs ( (String, Indicators) )
testPappybu_clause_no_pre d =
  case testPappypre_zei_bu d of
    Parsed p d1 e1 ->
      case testPappyStarRule191 d1 of
        Parsed bz d3 e3 ->
          case pappyResult5 of
            Parsed b d5 e5 ->
              case testPappypost_clause d5 of
                Parsed q d7 e7 ->
                  Parsed ( (p ++ concat bz ++ concat (replicate b " bu"), q) ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyPlusRule16 d3 of
                Parsed b d7 e7 ->
                  Parsed ( length b ) d7 e7
                NoParse e7 -> NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParsePlusRule15 :: TestPappyDerivs -> Result TestPappyDerivs ([ String ])
testPappyParsePlusRule15 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyzei_word d of
        Parsed v d3 e3 ->
          case testPappyPlusRule15 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 testPappyzei_word d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyzei_word :: TestPappyDerivs -> Result TestPappyDerivs ( String )
testPappyzei_word d =
  case testPappyZEI_pre d of
    Parsed _ d1 e1 ->
      case testPappyany_word d1 of
        Parsed w d3 e3 ->
          Parsed ( w ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParsePlusRule16 :: TestPappyDerivs -> Result TestPappyDerivs ([Pre])
testPappyParsePlusRule16 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyBU_pre d of
        Parsed v d3 e3 ->
          case testPappyPlusRule16 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 testPappyBU_pre d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsepre_zei_bu :: TestPappyDerivs -> Result TestPappyDerivs ( String )
testPappyParsepre_zei_bu d =
  case pappyResult1 of
    NoParse e1 ->
      case testPappyBU_pre d of
        NoParse e3 ->
          case testPappyZEI_pre d of
            NoParse e5 ->
              case testPappySI_clause d of
                NoParse e7 ->
                  case testPappySA_clause d of
                    NoParse e9 ->
                      case testPappySU_clause d of
                        NoParse e11 ->
                          case testPappyFAhO_clause d of
                            NoParse e13 ->
                              case testPappyany_word_SA_handling d of
                                Parsed w d15 e15 ->
                                  case pappyResult17 of
                                    Parsed _ d17 e17 ->
                                      Parsed ( snd w ) d17 (maximum [e17,e15,e13,e11,e9,e7,e5,e3,e1])
                                    NoParse e17 -> NoParse (maximum [e17,e15,e13,e11,e9,e7,e5,e3,e1])
                                  where
                                    pappyResult17 =
                                      case pappyResult19 of
                                        Parsed v19 d19 e19 -> Parsed (Just v19) d19 e19
                                        NoParse e19 -> Parsed (Nothing) d15 e19
                                      where
                                        pappyResult19 =
                                          case testPappyPlusRule17 d15 of
                                            Parsed _ d21 e21 ->
                                              Parsed ( () ) d21 e21
                                            NoParse e21 -> NoParse e21
                                NoParse e15 -> NoParse (maximum [e15,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])
        Parsed _ _ e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyPlusRule18 d of
        Parsed bs d3 e3 ->
          Parsed ( bs ) d3 e3
        NoParse e3 -> NoParse e3

testPappyParseStarRule192 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParseStarRule192 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyanyChar d of
        Parsed v d3 e3 ->
          case testPappyStarRule192 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

testPappyParseStarRule193 :: TestPappyDerivs -> Result TestPappyDerivs ([ [([String], String)] ])
testPappyParseStarRule193 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyindicators d of
        Parsed v d3 e3 ->
          case testPappyStarRule193 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

testPappypost_clause :: TestPappyDerivs -> Result TestPappyDerivs ( [[([String], String)]] )
testPappypost_clause d =
  case pappyResult1 of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyZEI_pre d3 of
            NoParse e5 ->
              case testPappyBU_pre d3 of
                NoParse e7 ->
                  case testPappyStarRule193 d3 of
                    Parsed is d9 e9 ->
                      Parsed ( is ) d9 (maximum [e9,e7,e5,e3,e1])
                    NoParse 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 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPlusRule17 d1 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyspaces d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappypost_clause_no_ind :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappypost_clause_no_ind d =
  case pappyResult1 of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyZEI_pre d3 of
            NoParse e5 ->
              case testPappyBU_pre d3 of
                NoParse e7 ->
                  Parsed ( () ) 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 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPlusRule17 d1 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyspaces d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappypre_clause :: TestPappyDerivs -> Result TestPappyDerivs ( [String] )
testPappypre_clause d =
  case pappyResult1 of
    Parsed b d1 e1 ->
      Parsed ( fromMaybe [] b ) d1 e1
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case pappyResult3 of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3
      where
        pappyResult3 =
          case testPappyPlusRule18 d of
            Parsed bs d5 e5 ->
              Parsed ( bs ) d5 e5
            NoParse e5 -> NoParse e5

testPappyParseany_word_SA_handling :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyParseany_word_SA_handling d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyBRIVLA_pre d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      pappyAlt3_1 e1 where
        pappyAlt3_1 e3 =
          case testPappyA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappyBAI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case testPappyBAhE d of
            Parsed b d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( ([], b) ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_4 (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 =
          case testPappyBE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_5 (max e5 e3)
        pappyAlt3_5 e3 =
          case testPappyBEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_6 (max e5 e3)
        pappyAlt3_6 e3 =
          case testPappyBEhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_7 (max e5 e3)
        pappyAlt3_7 e3 =
          case testPappyBIhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_8 (max e5 e3)
        pappyAlt3_8 e3 =
          case testPappyBIhI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_9 (max e5 e3)
        pappyAlt3_9 e3 =
          case testPappyBO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_10 (max e5 e3)
        pappyAlt3_10 e3 =
          case testPappyBOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_11 (max e5 e3)
        pappyAlt3_11 e3 =
          case testPappyBU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_12 (max e5 e3)
        pappyAlt3_12 e3 =
          case testPappyBY_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_13 (max e5 e3)
        pappyAlt3_13 e3 =
          case testPappyCAI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_14 (max e5 e3)
        pappyAlt3_14 e3 =
          case testPappyCAhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_15 (max e5 e3)
        pappyAlt3_15 e3 =
          case testPappyCEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_16 (max e5 e3)
        pappyAlt3_16 e3 =
          case testPappyCEhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_17 (max e5 e3)
        pappyAlt3_17 e3 =
          case testPappyCO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_18 (max e5 e3)
        pappyAlt3_18 e3 =
          case testPappyCOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_19 (max e5 e3)
        pappyAlt3_19 e3 =
          case testPappyCU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_20 (max e5 e3)
        pappyAlt3_20 e3 =
          case testPappyCUhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_21 (max e5 e3)
        pappyAlt3_21 e3 =
          case testPappyDAhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_22 (max e5 e3)
        pappyAlt3_22 e3 =
          case testPappyDOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_23 (max e5 e3)
        pappyAlt3_23 e3 =
          case testPappyDOhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_24 (max e5 e3)
        pappyAlt3_24 e3 =
          case testPappyFA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_25 (max e5 e3)
        pappyAlt3_25 e3 =
          case testPappyFAhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_26 (max e5 e3)
        pappyAlt3_26 e3 =
          case testPappyFEhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_27 (max e5 e3)
        pappyAlt3_27 e3 =
          case testPappyFEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_28 (max e5 e3)
        pappyAlt3_28 e3 =
          case testPappyFIhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_29 (max e5 e3)
        pappyAlt3_29 e3 =
          case testPappyFOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_30 (max e5 e3)
        pappyAlt3_30 e3 =
          case testPappyFUhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_31 (max e5 e3)
        pappyAlt3_31 e3 =
          case testPappyFUhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_32 (max e5 e3)
        pappyAlt3_32 e3 =
          case testPappyFUhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_33 (max e5 e3)
        pappyAlt3_33 e3 =
          case testPappyGA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_34 (max e5 e3)
        pappyAlt3_34 e3 =
          case testPappyGAhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_35 (max e5 e3)
        pappyAlt3_35 e3 =
          case testPappyGEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_36 (max e5 e3)
        pappyAlt3_36 e3 =
          case testPappyGI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_37 (max e5 e3)
        pappyAlt3_37 e3 =
          case testPappyGIhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_38 (max e5 e3)
        pappyAlt3_38 e3 =
          case testPappyGOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_39 (max e5 e3)
        pappyAlt3_39 e3 =
          case testPappyGOhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_40 (max e5 e3)
        pappyAlt3_40 e3 =
          case testPappyGUhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_41 (max e5 e3)
        pappyAlt3_41 e3 =
          case testPappyI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_42 (max e5 e3)
        pappyAlt3_42 e3 =
          case testPappyJA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_43 (max e5 e3)
        pappyAlt3_43 e3 =
          case testPappyJAI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_44 (max e5 e3)
        pappyAlt3_44 e3 =
          case testPappyJOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_45 (max e5 e3)
        pappyAlt3_45 e3 =
          case testPappyJOhI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_46 (max e5 e3)
        pappyAlt3_46 e3 =
          case testPappyKE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_47 (max e5 e3)
        pappyAlt3_47 e3 =
          case testPappyKEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_48 (max e5 e3)
        pappyAlt3_48 e3 =
          case testPappyKEhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_49 (max e5 e3)
        pappyAlt3_49 e3 =
          case testPappyKI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_50 (max e5 e3)
        pappyAlt3_50 e3 =
          case testPappyKOhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_51 (max e5 e3)
        pappyAlt3_51 e3 =
          case testPappyKU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_52 (max e5 e3)
        pappyAlt3_52 e3 =
          case testPappyKUhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_53 (max e5 e3)
        pappyAlt3_53 e3 =
          case testPappyKUhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_54 (max e5 e3)
        pappyAlt3_54 e3 =
          case testPappyLA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_55 (max e5 e3)
        pappyAlt3_55 e3 =
          case testPappyLAU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_56 (max e5 e3)
        pappyAlt3_56 e3 =
          case testPappyLAhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_57 (max e5 e3)
        pappyAlt3_57 e3 =
          case testPappyLE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_58 (max e5 e3)
        pappyAlt3_58 e3 =
          case testPappyLEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_59 (max e5 e3)
        pappyAlt3_59 e3 =
          case testPappyMAI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_60 (max e5 e3)
        pappyAlt3_60 e3 =
          case testPappyMAhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_61 (max e5 e3)
        pappyAlt3_61 e3 =
          case testPappyME_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_62 (max e5 e3)
        pappyAlt3_62 e3 =
          case testPappyMEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_63 (max e5 e3)
        pappyAlt3_63 e3 =
          case testPappyMOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_64 (max e5 e3)
        pappyAlt3_64 e3 =
          case testPappyMOhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_65 (max e5 e3)
        pappyAlt3_65 e3 =
          case testPappyMOhI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_66 (max e5 e3)
        pappyAlt3_66 e3 =
          case testPappyNA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_67 (max e5 e3)
        pappyAlt3_67 e3 =
          case testPappyNAI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_68 (max e5 e3)
        pappyAlt3_68 e3 =
          case testPappyNAhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_69 (max e5 e3)
        pappyAlt3_69 e3 =
          case testPappyNAhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_70 (max e5 e3)
        pappyAlt3_70 e3 =
          case testPappyNIhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_71 (max e5 e3)
        pappyAlt3_71 e3 =
          case testPappyNIhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_72 (max e5 e3)
        pappyAlt3_72 e3 =
          case testPappyNOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_73 (max e5 e3)
        pappyAlt3_73 e3 =
          case testPappyNU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_74 (max e5 e3)
        pappyAlt3_74 e3 =
          case testPappyNUhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_75 (max e5 e3)
        pappyAlt3_75 e3 =
          case testPappyNUhI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_76 (max e5 e3)
        pappyAlt3_76 e3 =
          case testPappyNUhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_77 (max e5 e3)
        pappyAlt3_77 e3 =
          case testPappyPA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_78 (max e5 e3)
        pappyAlt3_78 e3 =
          case testPappyPEhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_79 (max e5 e3)
        pappyAlt3_79 e3 =
          case testPappyPEhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_80 (max e5 e3)
        pappyAlt3_80 e3 =
          case testPappyPU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_81 (max e5 e3)
        pappyAlt3_81 e3 =
          case testPappyRAhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_82 (max e5 e3)
        pappyAlt3_82 e3 =
          case testPappyROI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_83 (max e5 e3)
        pappyAlt3_83 e3 =
          case testPappypre_clause d of
            Parsed _ d5 e5 ->
              case testPappySA d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      Parsed ( ([], s) ) d9 (maximum [e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_84 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case testPappyspaces d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_84 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_84 (max e5 e3)
        pappyAlt3_84 e3 =
          case testPappySE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_85 (max e5 e3)
        pappyAlt3_85 e3 =
          case testPappySEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_86 (max e5 e3)
        pappyAlt3_86 e3 =
          case testPappySEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_87 (max e5 e3)
        pappyAlt3_87 e3 =
          case pappyResult5 of
            Parsed _ d5 e5 ->
              case testPappySI d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      Parsed ( ([], s) ) d9 (maximum [e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_88 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case testPappyspaces d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_88 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_88 (max e5 e3)
          where
            pappyResult5 =
              case testPappyspaces d of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d e7
        pappyAlt3_88 e3 =
          case testPappySOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_89 (max e5 e3)
        pappyAlt3_89 e3 =
          case testPappypre_clause d of
            Parsed p d5 e5 ->
              case testPappySU d5 of
                Parsed s d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      Parsed ( (p, s) ) d9 (maximum [e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_90 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case testPappyspaces d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_90 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_90 (max e5 e3)
        pappyAlt3_90 e3 =
          case testPappyTAhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_91 (max e5 e3)
        pappyAlt3_91 e3 =
          case testPappyTEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_92 (max e5 e3)
        pappyAlt3_92 e3 =
          case testPappyTEhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_93 (max e5 e3)
        pappyAlt3_93 e3 =
          case testPappyTO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_94 (max e5 e3)
        pappyAlt3_94 e3 =
          case testPappyTOI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_95 (max e5 e3)
        pappyAlt3_95 e3 =
          case testPappyTUhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_96 (max e5 e3)
        pappyAlt3_96 e3 =
          case testPappyTUhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_97 (max e5 e3)
        pappyAlt3_97 e3 =
          case testPappyUI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_98 (max e5 e3)
        pappyAlt3_98 e3 =
          case testPappyVA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_99 (max e5 e3)
        pappyAlt3_99 e3 =
          case testPappyVAU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_100 (max e5 e3)
        pappyAlt3_100 e3 =
          case testPappyVEI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_101 (max e5 e3)
        pappyAlt3_101 e3 =
          case testPappyVEhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_102 (max e5 e3)
        pappyAlt3_102 e3 =
          case testPappyVEhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_103 (max e5 e3)
        pappyAlt3_103 e3 =
          case testPappyVIhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_104 (max e5 e3)
        pappyAlt3_104 e3 =
          case testPappyVUhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_105 (max e5 e3)
        pappyAlt3_105 e3 =
          case testPappyVUhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_106 (max e5 e3)
        pappyAlt3_106 e3 =
          case testPappyXI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_107 (max e5 e3)
        pappyAlt3_107 e3 =
          case testPappyZAhO_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_108 (max e5 e3)
        pappyAlt3_108 e3 =
          case testPappyZEI d of
            Parsed z d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( ([], z) ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> pappyAlt3_109 (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> pappyAlt3_109 (max e5 e3)
        pappyAlt3_109 e3 =
          case testPappyZEhA_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_110 (max e5 e3)
        pappyAlt3_110 e3 =
          case testPappyZI_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_111 (max e5 e3)
        pappyAlt3_111 e3 =
          case testPappyZIhE_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_112 (max e5 e3)
        pappyAlt3_112 e3 =
          case testPappypre_clause d of
            Parsed p d5 e5 ->
              case testPappyZO d5 of
                Parsed z d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      case testPappyany_word d9 of
                        Parsed w d11 e11 ->
                          case pappyResult13 of
                            Parsed _ d13 e13 ->
                              Parsed ( (p ++ [z], w) ) d13 (maximum [e13,e11,e9,e7,e5,e3])
                            NoParse e13 -> pappyAlt3_113 (maximum [e13,e11,e9,e7,e5,e3])
                          where
                            pappyResult13 =
                              case testPappyspaces d11 of
                                Parsed v15 d15 e15 -> Parsed (Just v15) d15 e15
                                NoParse e15 -> Parsed (Nothing) d11 e15
                        NoParse e11 -> pappyAlt3_113 (maximum [e11,e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_113 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case testPappyspaces d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_113 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_113 (max e5 e3)
        pappyAlt3_113 e3 =
          case testPappypre_clause d of
            Parsed p d5 e5 ->
              case testPappyZOI d5 of
                Parsed z d7 e7 ->
                  case pappyResult9 of
                    Parsed _ d9 e9 ->
                      case testPappyChar d9 of
                        Parsed w d11 e11 ->
                          case ( w == '\NUL' ) of
                            True ->
                              case pappyResult15 of
                                Parsed s d15 e15 ->
                                  case testPappyStarRule198 d15 of
                                    Parsed ws d17 e17 ->
                                      case testPappyChar d17 of
                                        Parsed v d19 e19 ->
                                          case ( v == '\NUL' ) of
                                            True ->
                                              case pappyResult23 of
                                                Parsed _ d23 e23 ->
                                                  Parsed ( (p, z ++ concat (maybe ws (: ws) s)) ) d23 (maximum [e23,e19,e17,e15,e11,e9,e7,e5,e3])
                                                NoParse e23 -> pappyAlt3_114 (maximum [e23,e19,e17,e15,e11,e9,e7,e5,e3])
                                              where
                                                pappyResult23 =
                                                  case testPappyspaces d19 of
                                                    Parsed v25 d25 e25 -> Parsed (Just v25) d25 e25
                                                    NoParse e25 -> Parsed (Nothing) d19 e25
                                            False -> pappyAlt3_114 (maximum [e19,e17,e15,e11,e9,e7,e5,e3])
                                        NoParse e19 -> pappyAlt3_114 (maximum [e19,e17,e15,e11,e9,e7,e5,e3])
                                    NoParse e17 -> pappyAlt3_114 (maximum [e17,e15,e11,e9,e7,e5,e3])
                                NoParse e15 -> pappyAlt3_114 (maximum [e15,e11,e9,e7,e5,e3])
                              where
                                pappyResult15 =
                                  case testPappyspaces d11 of
                                    Parsed v17 d17 e17 -> Parsed (Just v17) d17 e17
                                    NoParse e17 -> Parsed (Nothing) d11 e17
                            False -> pappyAlt3_114 (maximum [e11,e9,e7,e5,e3])
                        NoParse e11 -> pappyAlt3_114 (maximum [e11,e9,e7,e5,e3])
                    NoParse e9 -> pappyAlt3_114 (maximum [e9,e7,e5,e3])
                  where
                    pappyResult9 =
                      case testPappyspaces d7 of
                        Parsed v11 d11 e11 -> Parsed (Just v11) d11 e11
                        NoParse e11 -> Parsed (Nothing) d7 e11
                NoParse e7 -> pappyAlt3_114 (maximum [e7,e5,e3])
            NoParse e5 -> pappyAlt3_114 (max e5 e3)
        pappyAlt3_114 e3 =
          case testPappyZOhU_pre d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_115 (max e5 e3)
        pappyAlt3_115 e3 = pappyAlt1_3 e3
    pappyAlt1_3 e1 =
      case testPappypre_clause d of
        Parsed p d3 e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( (p, c) ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> pappyAlt1_4 (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyspaces 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 (testPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case testPappyA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyBAI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 =
                  case testPappyBAhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_4 (max e9 e7)
                pappyAlt7_4 e7 =
                  case testPappyBE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_5 (max e9 e7)
                pappyAlt7_5 e7 =
                  case testPappyBEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_6 (max e9 e7)
                pappyAlt7_6 e7 =
                  case testPappyBEhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_7 (max e9 e7)
                pappyAlt7_7 e7 =
                  case testPappyBIhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_8 (max e9 e7)
                pappyAlt7_8 e7 =
                  case testPappyBIhI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_9 (max e9 e7)
                pappyAlt7_9 e7 =
                  case testPappyBO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_10 (max e9 e7)
                pappyAlt7_10 e7 =
                  case testPappyBOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_11 (max e9 e7)
                pappyAlt7_11 e7 =
                  case testPappyBU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_12 (max e9 e7)
                pappyAlt7_12 e7 =
                  case testPappyBY d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_13 (max e9 e7)
                pappyAlt7_13 e7 =
                  case testPappyCAhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_14 (max e9 e7)
                pappyAlt7_14 e7 =
                  case testPappyCAI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_15 (max e9 e7)
                pappyAlt7_15 e7 =
                  case testPappyCEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_16 (max e9 e7)
                pappyAlt7_16 e7 =
                  case testPappyCEhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_17 (max e9 e7)
                pappyAlt7_17 e7 =
                  case testPappyCO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_18 (max e9 e7)
                pappyAlt7_18 e7 =
                  case testPappyCOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_19 (max e9 e7)
                pappyAlt7_19 e7 =
                  case testPappyCU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_20 (max e9 e7)
                pappyAlt7_20 e7 =
                  case testPappyCUhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_21 (max e9 e7)
                pappyAlt7_21 e7 =
                  case testPappyDAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_22 (max e9 e7)
                pappyAlt7_22 e7 =
                  case testPappyDOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_23 (max e9 e7)
                pappyAlt7_23 e7 =
                  case testPappyDOhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_24 (max e9 e7)
                pappyAlt7_24 e7 =
                  case testPappyFA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_25 (max e9 e7)
                pappyAlt7_25 e7 =
                  case testPappyFAhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_26 (max e9 e7)
                pappyAlt7_26 e7 =
                  case testPappyFAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_27 (max e9 e7)
                pappyAlt7_27 e7 =
                  case testPappyFEhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_28 (max e9 e7)
                pappyAlt7_28 e7 =
                  case testPappyFEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_29 (max e9 e7)
                pappyAlt7_29 e7 =
                  case testPappyFIhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_30 (max e9 e7)
                pappyAlt7_30 e7 =
                  case testPappyFOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_31 (max e9 e7)
                pappyAlt7_31 e7 =
                  case testPappyFUhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_32 (max e9 e7)
                pappyAlt7_32 e7 =
                  case testPappyFUhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_33 (max e9 e7)
                pappyAlt7_33 e7 =
                  case testPappyFUhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_34 (max e9 e7)
                pappyAlt7_34 e7 =
                  case testPappyGA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_35 (max e9 e7)
                pappyAlt7_35 e7 =
                  case testPappyGAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_36 (max e9 e7)
                pappyAlt7_36 e7 =
                  case testPappyGEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_37 (max e9 e7)
                pappyAlt7_37 e7 =
                  case testPappyGI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_38 (max e9 e7)
                pappyAlt7_38 e7 =
                  case testPappyGIhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_39 (max e9 e7)
                pappyAlt7_39 e7 =
                  case testPappyGOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_40 (max e9 e7)
                pappyAlt7_40 e7 =
                  case testPappyGOhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_41 (max e9 e7)
                pappyAlt7_41 e7 =
                  case testPappyGUhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_42 (max e9 e7)
                pappyAlt7_42 e7 =
                  case testPappyI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_43 (max e9 e7)
                pappyAlt7_43 e7 =
                  case testPappyJA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_44 (max e9 e7)
                pappyAlt7_44 e7 =
                  case testPappyJAI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_45 (max e9 e7)
                pappyAlt7_45 e7 =
                  case testPappyJOhI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_46 (max e9 e7)
                pappyAlt7_46 e7 =
                  case testPappyJOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_47 (max e9 e7)
                pappyAlt7_47 e7 =
                  case testPappyKE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_48 (max e9 e7)
                pappyAlt7_48 e7 =
                  case testPappyKEhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_49 (max e9 e7)
                pappyAlt7_49 e7 =
                  case testPappyKEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_50 (max e9 e7)
                pappyAlt7_50 e7 =
                  case testPappyKI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_51 (max e9 e7)
                pappyAlt7_51 e7 =
                  case testPappyKOhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_52 (max e9 e7)
                pappyAlt7_52 e7 =
                  case testPappyKU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_53 (max e9 e7)
                pappyAlt7_53 e7 =
                  case testPappyKUhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_54 (max e9 e7)
                pappyAlt7_54 e7 =
                  case testPappyKUhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_55 (max e9 e7)
                pappyAlt7_55 e7 =
                  case testPappyLA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_56 (max e9 e7)
                pappyAlt7_56 e7 =
                  case testPappyLAU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_57 (max e9 e7)
                pappyAlt7_57 e7 =
                  case testPappyLAhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_58 (max e9 e7)
                pappyAlt7_58 e7 =
                  case testPappyLE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_59 (max e9 e7)
                pappyAlt7_59 e7 =
                  case testPappyLEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_60 (max e9 e7)
                pappyAlt7_60 e7 =
                  case testPappyLI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_61 (max e9 e7)
                pappyAlt7_61 e7 =
                  case testPappyLIhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_62 (max e9 e7)
                pappyAlt7_62 e7 =
                  case testPappyLOhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_63 (max e9 e7)
                pappyAlt7_63 e7 =
                  case testPappyLOhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_64 (max e9 e7)
                pappyAlt7_64 e7 =
                  case testPappyLU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_65 (max e9 e7)
                pappyAlt7_65 e7 =
                  case testPappyLUhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_66 (max e9 e7)
                pappyAlt7_66 e7 =
                  case testPappyMAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_67 (max e9 e7)
                pappyAlt7_67 e7 =
                  case testPappyMAI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_68 (max e9 e7)
                pappyAlt7_68 e7 =
                  case testPappyME d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_69 (max e9 e7)
                pappyAlt7_69 e7 =
                  case testPappyMEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_70 (max e9 e7)
                pappyAlt7_70 e7 =
                  case testPappyMOhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_71 (max e9 e7)
                pappyAlt7_71 e7 =
                  case testPappyMOhI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_72 (max e9 e7)
                pappyAlt7_72 e7 =
                  case testPappyMOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_73 (max e9 e7)
                pappyAlt7_73 e7 =
                  case testPappyNA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_74 (max e9 e7)
                pappyAlt7_74 e7 =
                  case testPappyNAI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_75 (max e9 e7)
                pappyAlt7_75 e7 =
                  case testPappyNAhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_76 (max e9 e7)
                pappyAlt7_76 e7 =
                  case testPappyNAhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_77 (max e9 e7)
                pappyAlt7_77 e7 =
                  case testPappyNIhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_78 (max e9 e7)
                pappyAlt7_78 e7 =
                  case testPappyNIhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_79 (max e9 e7)
                pappyAlt7_79 e7 =
                  case testPappyNOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_80 (max e9 e7)
                pappyAlt7_80 e7 =
                  case testPappyNU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_81 (max e9 e7)
                pappyAlt7_81 e7 =
                  case testPappyNUhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_82 (max e9 e7)
                pappyAlt7_82 e7 =
                  case testPappyNUhI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_83 (max e9 e7)
                pappyAlt7_83 e7 =
                  case testPappyNUhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_84 (max e9 e7)
                pappyAlt7_84 e7 =
                  case testPappyPA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_85 (max e9 e7)
                pappyAlt7_85 e7 =
                  case testPappyPEhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_86 (max e9 e7)
                pappyAlt7_86 e7 =
                  case testPappyPEhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_87 (max e9 e7)
                pappyAlt7_87 e7 =
                  case testPappyPU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_88 (max e9 e7)
                pappyAlt7_88 e7 =
                  case testPappyRAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_89 (max e9 e7)
                pappyAlt7_89 e7 =
                  case testPappyROI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_90 (max e9 e7)
                pappyAlt7_90 e7 =
                  case testPappySA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_91 (max e9 e7)
                pappyAlt7_91 e7 =
                  case testPappySE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_92 (max e9 e7)
                pappyAlt7_92 e7 =
                  case testPappySEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_93 (max e9 e7)
                pappyAlt7_93 e7 =
                  case testPappySEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_94 (max e9 e7)
                pappyAlt7_94 e7 =
                  case testPappySI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_95 (max e9 e7)
                pappyAlt7_95 e7 =
                  case testPappySOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_96 (max e9 e7)
                pappyAlt7_96 e7 =
                  case testPappySU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_97 (max e9 e7)
                pappyAlt7_97 e7 =
                  case testPappyTAhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_98 (max e9 e7)
                pappyAlt7_98 e7 =
                  case testPappyTEhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_99 (max e9 e7)
                pappyAlt7_99 e7 =
                  case testPappyTEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_100 (max e9 e7)
                pappyAlt7_100 e7 =
                  case testPappyTO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_101 (max e9 e7)
                pappyAlt7_101 e7 =
                  case testPappyTOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_102 (max e9 e7)
                pappyAlt7_102 e7 =
                  case testPappyTUhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_103 (max e9 e7)
                pappyAlt7_103 e7 =
                  case testPappyTUhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_104 (max e9 e7)
                pappyAlt7_104 e7 =
                  case testPappyUI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_105 (max e9 e7)
                pappyAlt7_105 e7 =
                  case testPappyVA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_106 (max e9 e7)
                pappyAlt7_106 e7 =
                  case testPappyVAU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_107 (max e9 e7)
                pappyAlt7_107 e7 =
                  case testPappyVEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_108 (max e9 e7)
                pappyAlt7_108 e7 =
                  case testPappyVEhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_109 (max e9 e7)
                pappyAlt7_109 e7 =
                  case testPappyVUhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_110 (max e9 e7)
                pappyAlt7_110 e7 =
                  case testPappyVEhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_111 (max e9 e7)
                pappyAlt7_111 e7 =
                  case testPappyVIhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_112 (max e9 e7)
                pappyAlt7_112 e7 =
                  case testPappyVUhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_113 (max e9 e7)
                pappyAlt7_113 e7 =
                  case testPappyXI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_114 (max e9 e7)
                pappyAlt7_114 e7 =
                  case testPappyZAhO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_115 (max e9 e7)
                pappyAlt7_115 e7 =
                  case testPappyZEhA d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_116 (max e9 e7)
                pappyAlt7_116 e7 =
                  case testPappyZEI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_117 (max e9 e7)
                pappyAlt7_117 e7 =
                  case testPappyZI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_118 (max e9 e7)
                pappyAlt7_118 e7 =
                  case testPappyZIhE d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_119 (max e9 e7)
                pappyAlt7_119 e7 =
                  case testPappyZO d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_120 (max e9 e7)
                pappyAlt7_120 e7 =
                  case testPappyZOI d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_121 (max e9 e7)
                pappyAlt7_121 e7 =
                  case testPappyZOhU d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_122 (max e9 e7)
                pappyAlt7_122 e7 =
                  case testPappycmavo d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_123 (max e9 e7)
                pappyAlt7_123 e7 = NoParse e7
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyCMENE_pre d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 = NoParse e1

testPappyParseStarRule194 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule194 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule194 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyerasable_clause d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyNIhO_clause d of
                NoParse e7 ->
                  case testPappyLU_clause d of
                    NoParse e9 ->
                      case testPappyTUhE_clause d of
                        NoParse e11 ->
                          case testPappyTO_clause d of
                            NoParse e13 ->
                              case testPappySU_clause d of
                                NoParse e15 ->
                                  case testPappyFAhO_clause d of
                                    NoParse e17 ->
                                      case testPappyany_word_SA_handling d of
                                        Parsed _ d19 e19 ->
                                          Parsed ( () ) d19 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                        NoParse e19 -> pappyAlt5_3 (maximum [e19,e17,e15,e13,e11,e9,e7,e5])
                                    Parsed _ _ e17 -> pappyAlt5_3 (maximum [e17,e15,e13,e11,e9,e7,e5])
                                Parsed _ _ e15 -> pappyAlt5_3 (maximum [e15,e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    Parsed _ _ e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 = NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyParsePlusRule17 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParsePlusRule17 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappysi_clause_single d of
        Parsed v d3 e3 ->
          case testPappyPlusRule17 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 testPappysi_clause_single d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParsesi_clause_single :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParsesi_clause_single d =
  case pappyResult1 of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappySI_clause d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPlusRule17 d1 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappyerasable_clause d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappypre_zei_bu d of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case testPappySA_clause d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 = NoParse e3

testPappyParseerasable_clause :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyParseerasable_clause d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappybu_clause_no_pre d of
        Parsed _ d3 e3 ->
          case testPappyZEI_pre d3 of
            NoParse e5 ->
              case testPappyBU_pre d3 of
                NoParse e7 ->
                  Parsed ( () ) d3 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> pappyAlt1_2 (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyzei_clause_no_pre d of
        Parsed _ d3 e3 ->
          case testPappyZEI_pre d3 of
            NoParse e5 ->
              case testPappyBU_pre d3 of
                NoParse e7 ->
                  Parsed ( () ) d3 (maximum [e7,e5,e3,e1])
                Parsed _ _ e7 -> pappyAlt1_3 (maximum [e7,e5,e3,e1])
            Parsed _ _ e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseBRIVLA_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyParseBRIVLA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case pappyResult3 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappygismu d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappygismu d1 of
                NoParse e7 ->
                  case testPappyfuhivla d1 of
                    NoParse e9 ->
                      case testPappybrivla d1 of
                        Parsed b d11 e11 ->
                          Parsed ( b ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_3 (maximum [e11,e9,e7,e5])
                    Parsed _ _ e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                Parsed _ _ e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyfuhivla d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyCMENE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyCMENE_clause d =
  case testPappyCMENE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyCMENE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCMENE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappycmene d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyA d1 of
        Parsed a d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, a) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBAI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBAI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBAI d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyBE_clause d =
  case testPappyBE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyBE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBE d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBEI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyBEI_clause d =
  case testPappyBEI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyBEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBEI d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBEhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBEhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBEhO d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBIhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBIhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBIhE d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBIhI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBIhI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBIhI d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyBO_clause d =
  case testPappyBO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyBO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBO d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBOI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyBOI_clause d =
  case testPappyBOI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyBOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBOI d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyBU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBU_pre d =
  case testPappyBU d of
    Parsed b d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          Parsed ( ([], b) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyspaces d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyBY_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyBY_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyBY d1 of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, b) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyParsePlusRule18 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParsePlusRule18 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyBAhE_clause_single d of
        Parsed v d3 e3 ->
          case testPappyPlusRule18 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 testPappyBAhE_clause_single d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyBAhE_clause_single :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyBAhE_clause_single d =
  case pappyResult1 of
    Parsed b d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          case testPappyZEI_pre d3 of
            NoParse e5 ->
              case testPappyBU_pre d3 of
                NoParse e7 ->
                  Parsed ( b ) 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 =
          case pappyResult5 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
          where
            pappyResult5 =
              case testPappyPlusRule17 d1 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 e7
                NoParse e7 -> NoParse e7
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappyBAhE d of
        Parsed b d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( b ) d5 (max e5 e3)
            NoParse e5 -> NoParse (max e5 e3)
          where
            pappyResult5 =
              case testPappyspaces d3 of
                Parsed v7 d7 e7 -> Parsed (Just v7) d7 e7
                NoParse e7 -> Parsed (Nothing) d3 e7
        NoParse e3 -> NoParse e3

testPappyCAhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyCAhA_clause d =
  case testPappyCAhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyCAhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCAhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCAhA d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCAI_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyCAI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCAI d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCEI d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCEhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyCEhE_clause d =
  case testPappyCEhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyCEhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCEhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCEhE d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCO d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCOI d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyCU_clause d =
  case testPappyCU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyCU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCU d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyCUhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyCUhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyCUhE d1 of
        Parsed c d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, c) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyDAhO_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyDAhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyDAhO d1 of
        Parsed d d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, d) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyDOI_clause :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String, Indicators) )
testPappyDOI_clause d =
  case testPappyDOI_pre d of
    Parsed pre d1 e1 ->
      case testPappypost_clause d1 of
        Parsed post d3 e3 ->
          Parsed ( (fst pre, snd pre, post) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyDOI_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyDOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyDOI d1 of
        Parsed d d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, d) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyDOhU_clause :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String, Indicators) )
testPappyDOhU_clause d =
  case testPappyDOhU_pre d of
    Parsed pre d1 e1 ->
      case testPappypost_clause d1 of
        Parsed post d3 e3 ->
          Parsed ( (fst pre, snd pre, post) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyDOhU_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyDOhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyDOhU d1 of
        Parsed d d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, d) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyFA_clause d =
  case testPappyFA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyFA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFA d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFAhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyFAhA_clause d =
  case testPappyFAhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyFAhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFAhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFAhA d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFAhO_clause :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyFAhO_clause d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFAhO d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFEhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFEhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFEhE d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFEhU d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFIhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFIhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFIhO d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFOI d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFUhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyFUhA_clause d =
  case testPappyFUhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyFUhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyFUhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFUhA d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFUhE_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyFUhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFUhE d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyFUhO_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyFUhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyFUhO d1 of
        Parsed f d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, f) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGA d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGAhO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyGAhO_clause d =
  case testPappyGAhO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyGAhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGAhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGAhO d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGEhU d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyGI_clause d =
  case testPappyGI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyGI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGI d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGIhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGIhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGIhA d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGOI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyGOI_clause d =
  case testPappyGOI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyGOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGOI d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGOhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGOhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGOhA d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyGUhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyGUhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyGUhA d1 of
        Parsed g d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, g) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyParseStarRule195 :: TestPappyDerivs -> Result TestPappyDerivs ([ () ])
testPappyParseStarRule195 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule195 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 testPappysentence_start d of
            Parsed _ d5 e5 ->
              case testPappyStarRule23 d5 of
                Parsed _ d7 e7 ->
                  case testPappySA_clause d7 of
                    Parsed _ d9 e9 ->
                      case testPappytext_1 d9 of
                        Parsed _ _ e11 ->
                          Parsed ( () ) d9 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyI_clause d =
  case testPappyStarRule195 d of
    Parsed _ d1 e1 ->
      case testPappyI_pre d1 of
        Parsed p d3 e3 ->
          case testPappypost_clause d3 of
            Parsed q d5 e5 ->
              Parsed ( (fst p, snd p, q) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyI d1 of
        Parsed i d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, i) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyJA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyJA_clause d =
  case testPappyJA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyJA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyJA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyJA d1 of
        Parsed j d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, j) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyJAI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyJAI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyJAI d1 of
        Parsed j d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, j) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyJOhI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyJOhI_clause d =
  case testPappyJOhI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyJOhI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyJOhI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyJOhI d1 of
        Parsed j d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, j) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyJOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyJOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyJOI d1 of
        Parsed j d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, j) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyKE_clause d =
  case testPappyKE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyKE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKE d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyKI_clause d =
  case testPappyKI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyKI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKI d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKEhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyKEhE_clause d =
  case testPappyKEhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyKEhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKEhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKEhE d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKEI d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKOhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKOhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKOhA d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyKU_clause d =
  case testPappyKU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyKU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKU d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKUhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKUhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKUhE d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyKUhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyKUhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyKUhO d1 of
        Parsed k d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, k) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLA_clause d =
  case testPappyLA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyLA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyLA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyLA d1 of
        Parsed l d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, l) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLAhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLAhE_clause d =
  case testPappyLAhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyLAhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyLAhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyLAhE d1 of
        Parsed l d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, l) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLAU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyLAU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyLAU d1 of
        Parsed l d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, l) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLE_clause d =
  case testPappyLE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyLE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyLE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyLE d1 of
        Parsed l d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, l) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyLEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyLEhU d1 of
        Parsed l d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, l) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyLI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLI_clause d =
  case pappyResult1 of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappypre_clause d of
        Parsed p d3 e3 ->
          case testPappyLI d3 of
            Parsed l d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( (p, l) ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> NoParse (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyParseStarRule196 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule196 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule196 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 testPappyLEhU d of
            NoParse e5 ->
              case testPappyany_word d of
                Parsed w d7 e7 ->
                  Parsed ( w ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            Parsed _ _ e5 -> NoParse e5
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappyLU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLU_clause d =
  case pappyResult1 of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappypre_clause d of
        Parsed p d3 e3 ->
          case testPappyLU d3 of
            Parsed l d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( (p, l) ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> NoParse (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyLUhU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyLUhU_clause d =
  case pappyResult1 of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1
  where
    pappyResult1 =
      case testPappypre_clause d of
        Parsed p d3 e3 ->
          case testPappyLUhU d3 of
            Parsed l d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( (p, l) ) d7 (maximum [e7,e5,e3])
                NoParse e7 -> NoParse (maximum [e7,e5,e3])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (max e5 e3)
        NoParse e3 -> NoParse e3

testPappyMAhO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyMAhO_clause d =
  case testPappyMAhO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyMAhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMAhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMAhO d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyMAI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMAI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMAI d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyME_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyME_clause d =
  case testPappyME_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyME_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyME_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyME d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyMEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMEhU d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyMOhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyMOhE_clause d =
  case testPappyMOhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyMOhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMOhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMOhE d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyMOhI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMOhI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMOhI d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyMOI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyMOI_clause d =
  case testPappyMOI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyMOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyMOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyMOI d1 of
        Parsed m d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, m) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNA_clause d =
  case testPappyNA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNA d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNAI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNAI_clause d =
  case testPappyNAI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNAI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNAI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNAI d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNAhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNAhE_clause d =
  case testPappyNAhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNAhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNAhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNAhE d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNAhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNAhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNAhU d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNIhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNIhE_clause d =
  case testPappyNIhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNIhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNIhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNIhE d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNIhO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNIhO_clause d =
  case testPappyNIhO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNIhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNIhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNIhO d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNOI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNOI_clause d =
  case testPappyNOI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNOI d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNU_clause d =
  case testPappyNU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNU d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNUhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNUhA_clause d =
  case testPappyNUhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNUhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNUhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNUhA d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNUhI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNUhI_clause d =
  case testPappyNUhI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNUhI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNUhI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNUhI d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyNUhU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyNUhU_clause d =
  case testPappyNUhU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyNUhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyNUhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyNUhU d1 of
        Parsed n d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, n) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyPA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyPA_clause d =
  case testPappyPA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyPA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyPA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyPA d1 of
        Parsed q d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, q) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyPU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyPU_clause d =
  case testPappyPU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyPU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyPU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyPU d1 of
        Parsed q d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, q) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyPEhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyPEhE_clause d =
  case testPappyPEhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyPEhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyPEhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyPEhE d1 of
        Parsed q d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, q) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyPEhO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyPEhO_clause d =
  case testPappyPEhO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyPEhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyPEhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyPEhO d1 of
        Parsed q d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, q) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyRAhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyRAhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyRAhO d1 of
        Parsed r d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, r) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyROI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyROI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyROI d1 of
        Parsed r d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, r) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySA_clause :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappySA_clause d =
  case testPappypre_clause d of
    Parsed _ d1 e1 ->
      case testPappySA d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              case pappyResult7 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
              where
                pappyResult7 =
                  case testPappyspaces d5 of
                    Parsed v9 d9 e9 -> Parsed (Just v9) d9 e9
                    NoParse e9 -> Parsed (Nothing) d5 e9
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappySE_clause d =
  case testPappySE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappySE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappySE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappySE d1 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, s) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappySEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappySEI d1 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, s) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySEhU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappySEhU_clause d =
  case testPappySEhU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappySEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappySEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappySEhU d1 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, s) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySI_clause :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappySI_clause d =
  case pappyResult1 of
    Parsed _ d1 e1 ->
      case testPappySI d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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 =
      case testPappyspaces d of
        Parsed v3 d3 e3 -> Parsed (Just v3) d3 e3
        NoParse e3 -> Parsed (Nothing) d e3

testPappySOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappySOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappySOI d1 of
        Parsed s d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, s) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappySU_clause :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappySU_clause d =
  case testPappypre_clause d of
    Parsed _ d1 e1 ->
      case testPappySU d1 of
        Parsed _ d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              case testPappypost_clause d5 of
                Parsed _ d7 e7 ->
                  Parsed ( () ) d7 (maximum [e7,e5,e3,e1])
                NoParse e7 -> NoParse (maximum [e7,e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTAhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTAhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTAhE d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTEhU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyTEhU_clause d =
  case testPappyTEhU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyTEhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTEhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTEhU d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTEI d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyTO_clause d =
  case testPappyTO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyTO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTO d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTOI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTOI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTOI d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTUhE_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyTUhE_clause d =
  case testPappyTUhE_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyTUhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTUhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTUhE d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyTUhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyTUhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyTUhU d1 of
        Parsed t d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, t) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyUI_pre :: TestPappyDerivs -> Result TestPappyDerivs ( ([String], String) )
testPappyUI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyUI d1 of
        Parsed u d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, u) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVA_clause d =
  case testPappyVA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVA d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVAU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVAU_clause d =
  case testPappyVAU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVAU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVAU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVAU d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVEI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVEI_clause d =
  case testPappyVEI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVEI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVEI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVEI d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVEhO_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVEhO_clause d =
  case testPappyVEhO_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVEhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVEhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVEhO d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVUhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVUhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVUhO d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVUhU_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVUhU_clause d =
  case testPappyVUhU_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVUhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVUhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVUhU d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVEhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVEhA_clause d =
  case testPappyVEhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVEhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVEhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVEhA d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyVIhA_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyVIhA_clause d =
  case testPappyVIhA_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyVIhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyVIhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyVIhA d1 of
        Parsed v d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, v) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyXI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyXI_clause d =
  case testPappyXI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyXI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyXI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyXI d1 of
        Parsed x d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, x) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyZEhA_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyZEhA_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyZEhA d1 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyZEI_pre :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappyZEI_pre d =
  case testPappyZEI d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          Parsed ( () ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyspaces d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappyZI_clause :: TestPappyDerivs -> Result TestPappyDerivs (Clause)
testPappyZI_clause d =
  case testPappyZI_pre d of
    Parsed p d1 e1 ->
      case testPappypost_clause d1 of
        Parsed q d3 e3 ->
          Parsed ( (fst p, snd p, q) ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyZI_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyZI_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyZI d1 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyZIhE_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyZIhE_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyZIhE d1 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyParseStarRule198 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule198 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule198 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 s d7 e7 ->
                  Parsed ( maybe w (w ++) s ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
              where
                pappyResult7 =
                  case testPappyspaces 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 (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappylojban_word d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappylojban_word d of
                    NoParse e9 ->
                      case testPappyPlusRule22 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

testPappyZAhO_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyZAhO_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyZAhO d1 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyZOhU_pre :: TestPappyDerivs -> Result TestPappyDerivs (Pre)
testPappyZOhU_pre d =
  case testPappypre_clause d of
    Parsed p d1 e1 ->
      case testPappyZOhU d1 of
        Parsed z d3 e3 ->
          case pappyResult5 of
            Parsed _ d5 e5 ->
              Parsed ( (p, z) ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
          where
            pappyResult5 =
              case testPappyspaces 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

testPappyany_word :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyany_word d =
  case testPappylojban_word d of
    Parsed w d1 e1 ->
      case pappyResult3 of
        Parsed _ d3 e3 ->
          Parsed ( w ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyspaces d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappylojban_word :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappylojban_word d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappycmene d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappycmavo d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappybrivla d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParsePlusRule19 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParsePlusRule19 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyPlusRule19 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyany_syllable d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappydigit 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyany_syllable d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappydigit 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

testPappyParsecmene :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsecmene d =
  case testPappyh d of
    NoParse e1 ->
      case pappyResult3 of
        Parsed _ _ e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case testPappyPlusRule19 d5 of
                Parsed r d7 e7 ->
                  case testPappypause 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 testPappycoda 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 testPappyStarRule200 d of
            Parsed s d5 e5 ->
              case testPappyconsonant d5 of
                Parsed c d7 e7 ->
                  case testPappypause 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

testPappyParseStarRule200 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParseStarRule200 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule200 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 testPappynon_space d of
            Parsed n d5 e5 ->
              case testPappynon_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

testPappyParsecmavo :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsecmavo d =
  case testPappycmene d of
    NoParse e1 ->
      case pappyResult3 of
        NoParse e3 ->
          case pappyResult5 of
            Parsed c d5 e5 ->
              case testPappypost_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 (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappyh d of
                    NoParse e9 ->
                      case testPappycluster d of
                        NoParse e11 ->
                          case testPappyonset d of
                            Parsed o d13 e13 ->
                              case testPappyStarRule202 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 (testPappyPos d15) []) where
                                        pappyAlt19_1 e19 =
                                          case testPappystressed d15 of
                                            NoParse e21 ->
                                              case testPappynucleus 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 testPappynucleus d15 of
                                            Parsed n d21 e21 ->
                                              case testPappycluster 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 testPappyPlusRule24 d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 =
                  case testPappydigit 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyCVC_rafsi d of
                Parsed r d7 e7 ->
                  case testPappyy d7 of
                    Parsed y d9 e9 ->
                      case pappyResult11 of
                        Parsed h d11 e11 ->
                          case testPappyStarRule203 d11 of
                            Parsed rs d13 e13 ->
                              case testPappybrivla_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 testPappyh 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 testPappystressed_CVC_rafsi d of
                Parsed r d7 e7 ->
                  case testPappyy d7 of
                    Parsed y d9 e9 ->
                      case testPappyshort_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

testPappyParseStarRule202 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule202 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule202 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 testPappynucleus d of
            Parsed n d5 e5 ->
              case testPappyh 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

testPappyParseStarRule203 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule203 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule203 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyextended_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyy_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyany_extended_rafsi d of
                NoParse e7 ->
                  case testPappyy_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

testPappybrivla :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappybrivla d =
  case testPappycmavo d of
    NoParse e1 ->
      case testPappyStarRule203 d of
        Parsed rs d3 e3 ->
          case testPappybrivla_core d3 of
            Parsed b d5 e5 ->
              Parsed ( concat rs ++ b ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

testPappybrivla_core :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappybrivla_core d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyfuhivla d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappygismu d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyCVV_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 testPappyshort_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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappystressed_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 testPappystressed_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 testPappystressed_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

testPappyany_extended_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyany_extended_rafsi d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyfuhivla d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyextended_rafsi d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappystressed_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

testPappyfuhivla :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyfuhivla d =
  case testPappyfuhivla_head d of
    Parsed f d1 e1 ->
      case testPappystressed_syllable d1 of
        Parsed s d3 e3 ->
          case testPappyStarRule205 d3 of
            Parsed ss d5 e5 ->
              case testPappyfinal_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

testPappyParsestressed_extended_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsestressed_extended_rafsi d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyunstressed_syllable d of
        Parsed _ _ e3 ->
          case testPappybrivla_head d of
            Parsed b d5 e5 ->
              case testPappystressed_syllable d5 of
                Parsed s d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyy 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 testPappyfuhivla_head d of
        Parsed f d3 e3 ->
          case testPappystressed_syllable d3 of
            Parsed s d5 e5 ->
              case testPappyconsonant d5 of
                Parsed _ _ e7 ->
                  case testPappyonset d5 of
                    Parsed o d9 e9 ->
                      case testPappyy 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

testPappyParseextended_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseextended_rafsi d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed _ _ e3 ->
          case testPappybrivla_head d of
            Parsed b d5 e5 ->
              case testPappyh d5 of
                Parsed h d7 e7 ->
                  case testPappyy 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 testPappyh 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 testPappysyllable d of
            Parsed _ d5 e5 ->
              case testPappyStarRule205 d5 of
                Parsed _ d7 e7 ->
                  case testPappysyllable 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 testPappyunstressed_syllable d of
        Parsed _ _ e3 ->
          case testPappyfuhivla_head d of
            Parsed f d5 e5 ->
              case testPappyconsonant d5 of
                Parsed _ _ e7 ->
                  case testPappyonset d5 of
                    Parsed o d9 e9 ->
                      case testPappyy 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 testPappyh 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

testPappyParseStarRule205 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule205 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyconsonantal_syllable d of
        Parsed v d3 e3 ->
          case testPappyStarRule205 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

testPappyfuhivla_head :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyfuhivla_head d =
  case testPappyrafsi_string d of
    NoParse e1 ->
      case testPappybrivla_head d of
        Parsed b d3 e3 ->
          Parsed ( b ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

testPappyParseStarRule206 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule206 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyunstressed_syllable d of
        Parsed v d3 e3 ->
          case testPappyStarRule206 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

testPappyParsebrivla_head :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsebrivla_head d =
  case testPappycmavo d of
    NoParse e1 ->
      case pappyResult3 of
        NoParse e3 ->
          case testPappyh d of
            NoParse e5 ->
              case testPappyonset d of
                Parsed _ _ e7 ->
                  case testPappyStarRule206 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 testPappyconsonant d of
            Parsed c d5 e5 ->
              case testPappyrafsi_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

testPappyParseStarRule207 :: TestPappyDerivs -> Result TestPappyDerivs ([String])
testPappyParseStarRule207 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyy_less_rafsi d of
        Parsed v d3 e3 ->
          case testPappyStarRule207 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

testPappyrafsi_string :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyrafsi_string d =
  case testPappyStarRule207 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappygismu d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyCVV_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 testPappystressed_y_less_rafsi d1 of
                Parsed ylr d7 e7 ->
                  case testPappyshort_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 testPappyy_rafsi d1 of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappystressed_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 testPappyinitial_pair d7 of
                    Parsed p d9 e9 ->
                      case testPappyy 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 testPappystressed_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

testPappygismu :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappygismu d =
  case testPappystressed_long_rafsi d of
    Parsed r d1 e1 ->
      case testPappyfinal_syllable d1 of
        Parsed _ _ e3 ->
          case testPappyvowel d1 of
            Parsed v d5 e5 ->
              case testPappypost_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

testPappyParseCVV_final_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCVV_final_rafsi d =
  case testPappyconsonant d of
    Parsed c d1 e1 ->
      case testPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          case testPappyh d3 of
            Parsed h d5 e5 ->
              case testPappyfinal_syllable d5 of
                Parsed _ _ e7 ->
                  case testPappyvowel d5 of
                    Parsed w d9 e9 ->
                      case testPappypost_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

testPappyParseshort_final_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseshort_final_rafsi d =
  case testPappyfinal_syllable d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case testPappypost_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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyconsonant d of
                Parsed c d7 e7 ->
                  case testPappydiphthong 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 testPappyinitial_pair d of
                Parsed p d7 e7 ->
                  case testPappyvowel 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

testPappyParsestressed_y_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsestressed_y_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case testPappyy 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappystressed_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 testPappystressed_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

testPappyParsestressed_y_less_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsestressed_y_less_rafsi d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappystressed_CVC_rafsi d of
        Parsed r d3 e3 ->
          case testPappyy 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 testPappystressed_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 testPappyconsonant 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 testPappyr_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 (testPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case testPappyunstressed_vowel d3 of
                    Parsed v d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappystressed_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 testPappystressed d3 of
                        Parsed _ _ e11 ->
                          case testPappydiphthong 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 testPappydiphthong d3 of
                        Parsed d d11 e11 ->
                          case testPappystress 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

testPappyParsestressed_long_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsestressed_long_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case testPappyconsonant 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappystressed_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 testPappystressed_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

testPappystressed_CVC_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappystressed_CVC_rafsi d =
  case testPappyconsonant d of
    Parsed c d1 e1 ->
      case testPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          case testPappyconsonant 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

testPappystressed_CCV_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappystressed_CCV_rafsi d =
  case testPappyinitial_pair d of
    Parsed p d1 e1 ->
      case testPappystressed_vowel d1 of
        Parsed v d3 e3 ->
          Parsed ( p ++ [v] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParsey_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsey_rafsi d =
  case pappyResult1 of
    Parsed r d1 e1 ->
      case testPappyy 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 testPappyh 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case pappyResult5 of
            Parsed r d5 e5 ->
              case testPappyconsonant 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 (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappyCCV_rafsi d of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyCVC_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 testPappyCVC_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

testPappyParsey_less_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsey_less_rafsi d =
  case testPappyy_rafsi d of
    NoParse e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case testPappyany_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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyCVC_rafsi d of
                Parsed cvcr d7 e7 ->
                  case testPappyy 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 testPappyCCV_rafsi d of
                Parsed v7 d7 e7 -> Parsed v7 d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyconsonant 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 testPappyr_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 (testPappyPos d7) []) where
                        pappyAlt11_1 e11 =
                          case testPappyunstressed_vowel d7 of
                            Parsed v d13 e13 ->
                              case testPappyh d13 of
                                Parsed h d15 e15 ->
                                  case testPappyunstressed_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 testPappystressed d7 of
                                NoParse e15 ->
                                  case testPappydiphthong d7 of
                                    Parsed d d17 e17 ->
                                      case testPappystress 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

testPappyCVC_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyCVC_rafsi d =
  case testPappyconsonant d of
    Parsed c d1 e1 ->
      case testPappyunstressed_vowel d1 of
        Parsed v d3 e3 ->
          case testPappyconsonant 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

testPappyCCV_rafsi :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyCCV_rafsi d =
  case testPappyinitial_pair d of
    Parsed i d1 e1 ->
      case testPappyunstressed_vowel d1 of
        Parsed v d3 e3 ->
          Parsed ( i ++ [v] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParser_hyphen :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParser_hyphen d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyr d of
        Parsed r d3 e3 ->
          case testPappyconsonant 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 testPappyn d of
        Parsed n d3 e3 ->
          case testPappyr 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

testPappyParsefinal_syllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsefinal_syllable d =
  case testPappyonset d of
    Parsed o d1 e1 ->
      case testPappyy d1 of
        NoParse e3 ->
          case testPappystressed d1 of
            NoParse e5 ->
              case testPappynucleus d1 of
                Parsed n d7 e7 ->
                  case testPappycmene d7 of
                    NoParse e9 ->
                      case testPappypost_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

testPappyParsestressed_syllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsestressed_syllable d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappystressed d of
        Parsed _ _ e3 ->
          case testPappysyllable 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 testPappysyllable d of
        Parsed s d3 e3 ->
          case testPappystress 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

testPappyParsestressed_vowel :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsestressed_vowel d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappystressed d of
        Parsed _ _ e3 ->
          case testPappyvowel 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 testPappyvowel d of
        Parsed v d3 e3 ->
          case testPappystress 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

testPappyParseunstressed_syllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseunstressed_syllable d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappystressed d of
        NoParse e3 ->
          case testPappysyllable d of
            Parsed s d5 e5 ->
              case testPappystress 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 testPappyconsonantal_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

testPappyunstressed_vowel :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyunstressed_vowel d =
  case testPappystressed d of
    NoParse e1 ->
      case testPappyvowel d of
        Parsed v d3 e3 ->
          case testPappystress 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

testPappyParseStarRule208 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParseStarRule208 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyconsonant d of
        Parsed v d3 e3 ->
          case testPappyStarRule208 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

testPappystress :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappystress d =
  case testPappyStarRule208 d of
    Parsed c d1 e1 ->
      case pappyResult3 of
        Parsed y d3 e3 ->
          case testPappysyllable d3 of
            Parsed s d5 e5 ->
              case testPappypause 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 testPappyy d1 of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d1 e5
    NoParse e1 -> NoParse e1

testPappystressed :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappystressed d =
  case testPappyonset d of
    Parsed o d1 e1 ->
      case testPappyStarRule236 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 (testPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case testPappyChar d3 of
                    r @ (Parsed 'A' _ _) -> r
                    _ -> pappyAlt7_2 e7
                pappyAlt7_2 e7 =
                  case testPappyChar d3 of
                    r @ (Parsed 'E' _ _) -> r
                    _ -> pappyAlt7_3 e7
                pappyAlt7_3 e7 =
                  case testPappyChar d3 of
                    r @ (Parsed 'I' _ _) -> r
                    _ -> pappyAlt7_4 e7
                pappyAlt7_4 e7 =
                  case testPappyChar d3 of
                    r @ (Parsed 'O' _ _) -> r
                    _ -> pappyAlt7_5 e7
                pappyAlt7_5 e7 =
                  case testPappyChar d3 of
                    r @ (Parsed 'U' _ _) -> r
                    _ -> pappyAlt7_6 e7
                pappyAlt7_6 e7 = NoParse e7
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyany_syllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyany_syllable d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyonset d of
        Parsed o d3 e3 ->
          case testPappynucleus 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 testPappycoda 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 testPappyconsonantal_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

testPappysyllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappysyllable d =
  case testPappyonset d of
    Parsed o d1 e1 ->
      case testPappyy d1 of
        NoParse e3 ->
          case testPappynucleus 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 testPappycoda 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

testPappyParseconsonantal_syllable :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseconsonantal_syllable d =
  case testPappyconsonant d of
    Parsed c d1 e1 ->
      case testPappysyllabic 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 testPappyconsonant d3 of
                        Parsed cin d11 e11 ->
                          case testPappyspaces 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 (testPappyPos d3) []) where
                pappyAlt7_1 e7 =
                  case testPappyconsonantal_syllable d3 of
                    Parsed v9 d9 e9 -> Parsed v9 d9 (max e9 e7)
                    NoParse e9 -> pappyAlt7_2 (max e9 e7)
                pappyAlt7_2 e7 =
                  case testPappyonset 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

testPappyParsecoda :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsecoda d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyany_syllable d of
        NoParse e3 ->
          case testPappyconsonant d of
            Parsed c d5 e5 ->
              case testPappyany_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 testPappypause 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 testPappyconsonant 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 testPappysyllabic d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 = NoParse e1

testPappyParseonset :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseonset d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyh 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 testPappyglide 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 testPappyconsonant d of
            Parsed v5 d5 e5 -> Parsed (Just v5) d5 e5
            NoParse e5 -> Parsed (Nothing) d e5
    pappyAlt1_3 e1 =
      case testPappyinitial d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappynucleus :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappynucleus d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyvowel d of
        Parsed v d3 e3 ->
          Parsed ( [v] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappydiphthong d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyy d of
        Parsed y d3 e3 ->
          Parsed ( [y] ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappyParseglide :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParseglide d =
  case pappyResult1 of
    Parsed v d1 e1 ->
      case testPappynucleus d1 of
        Parsed _ _ e3 ->
          case testPappyglide 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappyi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappyu d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 = NoParse e3

testPappyParsediphthong :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsediphthong d =
  case pappyResult1 of
    Parsed d d1 e1 ->
      case testPappynucleus d1 of
        NoParse e3 ->
          case testPappyglide 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappya d of
            Parsed v d5 e5 ->
              case testPappyi 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 testPappya d of
            Parsed v d5 e5 ->
              case testPappyu 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 testPappye d of
            Parsed v d5 e5 ->
              case testPappyi 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 testPappyo d of
            Parsed v d5 e5 ->
              case testPappyi 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

testPappyParsevowel :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsevowel d =
  case pappyResult1 of
    Parsed v d1 e1 ->
      case testPappynucleus 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappya d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_2 (max e5 e3)
        pappyAlt3_2 e3 =
          case testPappye d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_3 (max e5 e3)
        pappyAlt3_3 e3 =
          case testPappyi d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_4 (max e5 e3)
        pappyAlt3_4 e3 =
          case testPappyo d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_5 (max e5 e3)
        pappyAlt3_5 e3 =
          case testPappyu d of
            Parsed v5 d5 e5 -> Parsed v5 d5 (max e5 e3)
            NoParse e5 -> pappyAlt3_6 (max e5 e3)
        pappyAlt3_6 e3 = NoParse e3

testPappya :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappya d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'a' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'A' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappye :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappye d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'e' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'E' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyi :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyi d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'i' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'I' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyo :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyo d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'o' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'O' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyu :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyu d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'u' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'U' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyy :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyy d =
  case testPappyStarRule236 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'y' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'Y' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePlusRule21 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParsePlusRule21 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyconsonant d of
        Parsed v d3 e3 ->
          case testPappyPlusRule21 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 testPappyconsonant d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappycluster :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappycluster d =
  case testPappyconsonant d of
    Parsed c d1 e1 ->
      case testPappyPlusRule21 d1 of
        Parsed cs d3 e3 ->
          Parsed ( c : cs ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseinitial_pair :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseinitial_pair d =
  case testPappyinitial d of
    Parsed _ _ e1 ->
      case testPappyconsonant d of
        Parsed c d3 e3 ->
          case testPappyconsonant d3 of
            Parsed d d5 e5 ->
              case testPappyconsonant 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

testPappyParseinitial :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseinitial d =
  case pappyResult1 of
    Parsed i d1 e1 ->
      case testPappyconsonant d1 of
        NoParse e3 ->
          case testPappyglide 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 (testPappyPos d) []) where
        pappyAlt3_1 e3 =
          case testPappyaffricate 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 testPappyliquid 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 (testPappyPos d5) []) where
                        pappyAlt11_1 e11 =
                          case testPappyp d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_2 (max e13 e11)
                        pappyAlt11_2 e11 =
                          case testPappyt d5 of
                            Parsed t d13 e13 ->
                              case testPappyl 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 testPappyk d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_4 (max e13 e11)
                        pappyAlt11_4 e11 =
                          case testPappyf d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_5 (max e13 e11)
                        pappyAlt11_5 e11 =
                          case testPappyx d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_6 (max e13 e11)
                        pappyAlt11_6 e11 =
                          case testPappyb d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_7 (max e13 e11)
                        pappyAlt11_7 e11 =
                          case testPappyd d5 of
                            Parsed d d13 e13 ->
                              case testPappyl 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 testPappyg d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_9 (max e13 e11)
                        pappyAlt11_9 e11 =
                          case testPappyv d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_10 (max e13 e11)
                        pappyAlt11_10 e11 =
                          case testPappym d5 of
                            Parsed v13 d13 e13 -> Parsed v13 d13 (max e13 e11)
                            NoParse e13 -> pappyAlt11_11 (max e13 e11)
                        pappyAlt11_11 e11 =
                          case testPappyn d5 of
                            Parsed n d13 e13 ->
                              case testPappyliquid 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 (testPappyPos d) []) where
                    pappyAlt9_1 e9 =
                      case testPappyc d of
                        Parsed v11 d11 e11 -> Parsed v11 d11 (max e11 e9)
                        NoParse e11 -> pappyAlt9_2 (max e11 e9)
                    pappyAlt9_2 e9 =
                      case testPappys d of
                        Parsed s d11 e11 ->
                          case testPappyx 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 testPappyn d11 of
                            NoParse e13 ->
                              case testPappyliquid 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 (testPappyPos d) []) where
                            pappyAlt13_1 e13 =
                              case testPappyj d of
                                Parsed v15 d15 e15 -> Parsed v15 d15 (max e15 e13)
                                NoParse e15 -> pappyAlt13_2 (max e15 e13)
                            pappyAlt13_2 e13 =
                              case testPappyz 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

testPappyaffricate :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyaffricate d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyt d of
        Parsed t d3 e3 ->
          case testPappyc 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 testPappyt d of
        Parsed t d3 e3 ->
          case testPappys 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 testPappyd d of
        Parsed d d3 e3 ->
          case testPappyj 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 testPappyd d of
        Parsed d d3 e3 ->
          case testPappyz 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

testPappyliquid :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyliquid d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyl d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyr d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyconsonant :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyconsonant d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyvoiced d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyunvoiced d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappysyllabic d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 = NoParse e1

testPappysyllabic :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappysyllabic d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyl d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappym d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyn d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyr d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 = NoParse e1

testPappyvoiced :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyvoiced d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyb d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyd d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyg d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyj d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappyv d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyz d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 = NoParse e1

testPappyunvoiced :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyunvoiced d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyc d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyf d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 =
      case testPappyk d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_4 (max e3 e1)
    pappyAlt1_4 e1 =
      case testPappyp d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_5 (max e3 e1)
    pappyAlt1_5 e1 =
      case testPappys d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_6 (max e3 e1)
    pappyAlt1_6 e1 =
      case testPappyt d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_7 (max e3 e1)
    pappyAlt1_7 e1 =
      case testPappyx d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_8 (max e3 e1)
    pappyAlt1_8 e1 = NoParse e1

testPappyParsel :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsel d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed l d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyl 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'l' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'L' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsem :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsem d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed m d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappym d3 of
                NoParse e7 ->
                  case testPappyz 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'm' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'M' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsen :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsen d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed n d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyn d3 of
                NoParse e7 ->
                  case testPappyaffricate 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'n' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'N' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParser :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParser d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed r d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyr 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'r' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'R' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseb :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParseb d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed b d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyb d3 of
                NoParse e7 ->
                  case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'b' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'B' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsed :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsed d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed d d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyd d3 of
                NoParse e7 ->
                  case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'd' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'D' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseg :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParseg d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed g d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyg d3 of
                NoParse e7 ->
                  case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'g' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'G' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsev :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsev d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyv d3 of
                NoParse e7 ->
                  case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'v' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'V' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsej :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsej d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed j d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyj d3 of
                NoParse e7 ->
                  case testPappyz d3 of
                    NoParse e9 ->
                      case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'j' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'J' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsez :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsez d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed z d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyz d3 of
                NoParse e7 ->
                  case testPappyj d3 of
                    NoParse e9 ->
                      case testPappyunvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'z' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'Z' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParses :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParses d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed s d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappys d3 of
                NoParse e7 ->
                  case testPappyc d3 of
                    NoParse e9 ->
                      case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 's' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'S' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsec :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsec d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed c d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyc d3 of
                NoParse e7 ->
                  case testPappys d3 of
                    NoParse e9 ->
                      case testPappyx d3 of
                        NoParse e11 ->
                          case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'c' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'C' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsex :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsex d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed x d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyx d3 of
                NoParse e7 ->
                  case testPappyc d3 of
                    NoParse e9 ->
                      case testPappyk d3 of
                        NoParse e11 ->
                          case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'x' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'X' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsek :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsek d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed k d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyk d3 of
                NoParse e7 ->
                  case testPappyx d3 of
                    NoParse e9 ->
                      case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'k' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'K' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsef :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsef d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed f d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyf d3 of
                NoParse e7 ->
                  case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'f' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'F' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsep :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsep d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed p d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyp d3 of
                NoParse e7 ->
                  case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'p' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'P' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParset :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParset d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed t d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappyt d3 of
                NoParse e7 ->
                  case testPappyvoiced 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 't' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'T' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyh :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyh d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed h d3 e3 ->
          case testPappynucleus 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed 'h' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed '\'' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsedigit :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyParsedigit d =
  case testPappyStarRule236 d of
    Parsed _ d1 e1 ->
      case pappyResult3 of
        Parsed d d3 e3 ->
          case testPappyh d3 of
            NoParse e5 ->
              case testPappynucleus 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 (testPappyPos d1) []) where
            pappyAlt5_1 e5 =
              case testPappyChar d1 of
                r @ (Parsed '0' _ _) -> r
                _ -> pappyAlt5_2 e5
            pappyAlt5_2 e5 =
              case testPappyChar d1 of
                r @ (Parsed '1' _ _) -> r
                _ -> pappyAlt5_3 e5
            pappyAlt5_3 e5 =
              case testPappyChar d1 of
                r @ (Parsed '2' _ _) -> r
                _ -> pappyAlt5_4 e5
            pappyAlt5_4 e5 =
              case testPappyChar d1 of
                r @ (Parsed '3' _ _) -> r
                _ -> pappyAlt5_5 e5
            pappyAlt5_5 e5 =
              case testPappyChar d1 of
                r @ (Parsed '4' _ _) -> r
                _ -> pappyAlt5_6 e5
            pappyAlt5_6 e5 =
              case testPappyChar d1 of
                r @ (Parsed '5' _ _) -> r
                _ -> pappyAlt5_7 e5
            pappyAlt5_7 e5 =
              case testPappyChar d1 of
                r @ (Parsed '6' _ _) -> r
                _ -> pappyAlt5_8 e5
            pappyAlt5_8 e5 =
              case testPappyChar d1 of
                r @ (Parsed '7' _ _) -> r
                _ -> pappyAlt5_9 e5
            pappyAlt5_9 e5 =
              case testPappyChar d1 of
                r @ (Parsed '8' _ _) -> r
                _ -> pappyAlt5_10 e5
            pappyAlt5_10 e5 =
              case testPappyChar d1 of
                r @ (Parsed '9' _ _) -> r
                _ -> pappyAlt5_11 e5
            pappyAlt5_11 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsepost_word :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsepost_word d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappypause d of
        Parsed _ d3 e3 ->
          Parsed ( "" ) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappynucleus d of
        NoParse e3 ->
          case testPappylojban_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

testPappypause :: TestPappyDerivs -> Result TestPappyDerivs ( () )
testPappypause d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyStarRule236 d of
        Parsed _ d3 e3 ->
          case testPappyspace_char d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_2 (maximum [e5,e3,e1])
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappyanyChar d of
        NoParse e3 ->
          Parsed ( () ) d (max e3 e1)
        Parsed _ _ e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyanyChar :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyanyChar d =
  case testPappyChar d of
    Parsed c d1 e1 ->
      case ( True ) of
        True ->
          Parsed ( c ) d1 e1
        False -> NoParse e1
    NoParse e1 -> NoParse e1

testPappyParsePlusRule22 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParsePlusRule22 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappynon_space d of
        Parsed v d3 e3 ->
          case testPappyPlusRule22 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 testPappynon_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

testPappynon_space :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappynon_space d =
  case testPappyspace_char d of
    NoParse e1 ->
      case testPappyanyChar d of
        Parsed c d3 e3 ->
          case ( c /= '\NUL' ) of
            True ->
              Parsed ( c ) d3 (max e3 e1)
            False -> NoParse (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    Parsed _ _ e1 -> NoParse e1

testPappyspace_char :: TestPappyDerivs -> Result TestPappyDerivs (Char)
testPappyspace_char d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyChar d of
        r @ (Parsed '.' _ _) -> r
        _ -> pappyAlt1_2 e1
    pappyAlt1_2 e1 =
      case testPappyChar d of
        r @ (Parsed '?' _ _) -> r
        _ -> pappyAlt1_3 e1
    pappyAlt1_3 e1 =
      case testPappyChar d of
        r @ (Parsed '!' _ _) -> r
        _ -> pappyAlt1_4 e1
    pappyAlt1_4 e1 =
      case testPappyChar d of
        r @ (Parsed ' ' _ _) -> r
        _ -> pappyAlt1_5 e1
    pappyAlt1_5 e1 =
      case testPappyChar d of
        r @ (Parsed '\t' _ _) -> r
        _ -> pappyAlt1_6 e1
    pappyAlt1_6 e1 =
      case testPappyChar d of
        r @ (Parsed '\r' _ _) -> r
        _ -> pappyAlt1_7 e1
    pappyAlt1_7 e1 =
      case testPappyChar d of
        r @ (Parsed '\n' _ _) -> r
        _ -> pappyAlt1_8 e1
    pappyAlt1_8 e1 = NoParse e1

testPappyspaces :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyspaces d =
  case testPappyY 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyPlusRule23 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 testPappyanyChar d7 of
                            NoParse e13 ->
                              Parsed ( () ) d7 e13
                            Parsed _ _ e13 -> NoParse e13
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyanyChar 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

testPappyParsePlusRule23 :: TestPappyDerivs -> Result TestPappyDerivs ([ String ])
testPappyParsePlusRule23 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyPlusRule23 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappycomma_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 testPappyybu d of
                NoParse e7 ->
                  case testPappyY 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappycomma_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 testPappyybu d of
                NoParse e7 ->
                  case testPappyY 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

testPappyParseStarRule236 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParseStarRule236 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case pappyResult3 of
        Parsed v d3 e3 ->
          case testPappyStarRule236 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 testPappyChar d of
            r @ (Parsed ',' _ _) -> r
            _ -> NoParse (ParseError (testPappyPos d) [])
    pappyAlt1_2 e1 =
      Parsed ([]) d e1
    pappyAlt1_3 e1 = NoParse e1

testPappycomma_space_char :: TestPappyDerivs -> Result TestPappyDerivs ( String )
testPappycomma_space_char d =
  case testPappyStarRule236 d of
    Parsed c d1 e1 ->
      case testPappyspace_char d1 of
        Parsed s d3 e3 ->
          Parsed ( c ++ [s] ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseStarRule237 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParseStarRule237 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyspace_char d of
        Parsed v d3 e3 ->
          case testPappyStarRule237 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

testPappyybu :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyybu d =
  case testPappyY d of
    Parsed y d1 e1 ->
      case testPappyStarRule237 d1 of
        Parsed _ d3 e3 ->
          case testPappyBU d3 of
            Parsed b d5 e5 ->
              Parsed ( y ++ b ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> NoParse (maximum [e5,e3,e1])
        NoParse e3 -> NoParse (max e3 e1)
    NoParse e1 -> NoParse e1

testPappyParseA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseA d =
  case testPappycmavo d of
    Parsed _ _ 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 (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  Parsed ( [a] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  Parsed ( [e] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [j, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  Parsed ( [o] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  Parsed ( [u] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBAI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBAI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bai d3 e3 ->
          Parsed ( bai ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [d, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [s, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [z, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [k, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [d, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [c, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [t, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [t, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [d, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [j, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [r, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [n, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [m, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [k, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [v, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [k, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [c, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_18 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_18 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [t, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_19 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [p, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_20 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [j, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_21 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_21 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [k, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [b, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_23 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [f, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_24 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_24 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_24 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_24 (max e7 e5)
            pappyAlt5_24 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [d, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_25 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_25 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_25 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_25 (max e7 e5)
            pappyAlt5_25 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [c, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_26 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_26 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_26 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_26 (max e7 e5)
            pappyAlt5_26 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [m, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_27 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_27 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_27 (max e7 e5)
            pappyAlt5_27 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [m, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_28 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_28 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_28 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_28 (max e7 e5)
            pappyAlt5_28 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [r, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_29 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_29 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_29 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_29 (max e7 e5)
            pappyAlt5_29 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [r, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_30 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_30 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_30 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_30 (max e7 e5)
            pappyAlt5_30 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [k, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_31 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_31 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_31 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_31 (max e7 e5)
            pappyAlt5_31 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [p, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_32 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_32 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_32 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_32 (max e7 e5)
            pappyAlt5_32 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [p, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_33 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_33 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_33 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_33 (max e7 e5)
            pappyAlt5_33 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [l, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_34 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_34 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_34 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_34 (max e7 e5)
            pappyAlt5_34 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [k, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_35 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_35 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_35 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_35 (max e7 e5)
            pappyAlt5_35 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [t, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_36 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_36 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_36 (max e7 e5)
            pappyAlt5_36 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [b, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_37 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_37 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_37 (max e7 e5)
            pappyAlt5_37 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [m, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_38 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_38 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_38 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_38 (max e7 e5)
            pappyAlt5_38 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [c, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_39 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_39 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_39 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_39 (max e7 e5)
            pappyAlt5_39 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [f, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_40 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_40 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_40 (max e7 e5)
            pappyAlt5_40 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [p, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_41 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_41 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_41 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_41 (max e7 e5)
            pappyAlt5_41 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [c, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_42 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_42 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_42 (max e7 e5)
            pappyAlt5_42 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [m, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_43 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_43 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_43 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_43 (max e7 e5)
            pappyAlt5_43 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [c, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_44 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_44 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_44 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_44 (max e7 e5)
            pappyAlt5_44 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [r, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_45 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_45 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_45 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_45 (max e7 e5)
            pappyAlt5_45 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [p, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_46 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_46 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_46 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_46 (max e7 e5)
            pappyAlt5_46 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [l, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_47 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_47 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_47 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_47 (max e7 e5)
            pappyAlt5_47 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [l, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_48 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_48 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_48 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_48 (max e7 e5)
            pappyAlt5_48 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [b, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_49 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_49 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_49 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_49 (max e7 e5)
            pappyAlt5_49 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [k, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_50 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_50 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_50 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_50 (max e7 e5)
            pappyAlt5_50 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [s, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_51 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_51 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_51 (max e7 e5)
            pappyAlt5_51 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [f, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_52 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_52 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_52 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_52 (max e7 e5)
            pappyAlt5_52 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [b, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_53 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_53 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_53 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_53 (max e7 e5)
            pappyAlt5_53 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [t, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_54 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_54 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_54 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_54 (max e7 e5)
            pappyAlt5_54 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [j, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_55 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_55 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_55 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_55 (max e7 e5)
            pappyAlt5_55 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [g, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_56 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_56 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_56 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_56 (max e7 e5)
            pappyAlt5_56 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [v, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_57 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_57 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_57 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_57 (max e7 e5)
            pappyAlt5_57 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [j, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_58 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_58 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_58 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_58 (max e7 e5)
            pappyAlt5_58 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [m, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_59 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_59 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_59 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_59 (max e7 e5)
            pappyAlt5_59 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [d, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_60 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_60 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_60 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_60 (max e7 e5)
            pappyAlt5_60 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [j, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_61 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_61 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_61 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_61 (max e7 e5)
            pappyAlt5_61 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [p, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_62 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_62 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_62 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_62 (max e7 e5)
            pappyAlt5_62 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [g, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_63 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_63 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_63 (max e7 e5)
            pappyAlt5_63 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [z, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_64 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_64 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_64 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_64 (max e7 e5)
            pappyAlt5_64 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [m, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_65 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_65 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_65 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_65 (max e7 e5)
            pappyAlt5_65 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [r, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_66 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_66 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_66 (max e7 e5)
            pappyAlt5_66 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBAhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBAhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bahe d3 e3 ->
          Parsed ( bahe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [b, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [z, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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
    NoParse e1 -> NoParse e1

testPappyBE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyBE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed be d3 e3 ->
          Parsed ( be ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  Parsed ( [b, e] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyBEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyBEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bei d3 e3 ->
          Parsed ( bei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [b, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBEhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBEhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed beho d3 e3 ->
          Parsed ( beho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [b, e, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBIhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBIhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bihe d3 e3 ->
          Parsed ( bihe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [b, i, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBIhI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBIhI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bihi d3 e3 ->
          Parsed ( bihi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [m, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [b, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [b, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyBO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyBO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bo d3 e3 ->
          Parsed ( bo ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  Parsed ( [b, o] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyBOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyBOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed boi d3 e3 ->
          Parsed ( boi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [b, o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed bu d3 e3 ->
          Parsed ( bu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyb d of
            Parsed b d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    NoParse e9 ->
                      Parsed ( [b, u] ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseBY :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseBY d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyybu d of
        Parsed v3 d3 e3 -> Parsed v3 d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_2 (max e3 e1)
    pappyAlt1_2 e1 =
      case testPappycmavo d of
        Parsed _ _ e3 ->
          case pappyResult5 of
            Parsed by d5 e5 ->
              Parsed ( by ) d5 (maximum [e5,e3,e1])
            NoParse e5 -> pappyAlt1_3 (maximum [e5,e3,e1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (testPappyPos d) []) where
                pappyAlt7_1 e7 =
                  case testPappyj d of
                    Parsed j d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappyo d13 of
                                Parsed o d15 e15 ->
                                  Parsed ( [j, o, h, o] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_2 (maximum [e15,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 =
                  case testPappyr d of
                    Parsed r d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappyo d13 of
                                Parsed o d15 e15 ->
                                  Parsed ( [r, u, h, o] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_3 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_3 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_3 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_3 (max e9 e7)
                pappyAlt7_3 e7 =
                  case testPappyg d of
                    Parsed g d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappyo d13 of
                                Parsed o d15 e15 ->
                                  Parsed ( [g, e, h, o] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_4 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_4 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_4 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_4 (max e9 e7)
                pappyAlt7_4 e7 =
                  case testPappyj d of
                    Parsed j d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappyo d13 of
                                Parsed o d15 e15 ->
                                  Parsed ( [j, e, h, o] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_5 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_5 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_5 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_5 (max e9 e7)
                pappyAlt7_5 e7 =
                  case testPappyl d of
                    Parsed l d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappya d13 of
                                Parsed a d15 e15 ->
                                  Parsed ( [l, o, h, a] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_6 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_6 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_6 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_6 (max e9 e7)
                pappyAlt7_6 e7 =
                  case testPappyn d of
                    Parsed n d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappya d13 of
                                Parsed a d15 e15 ->
                                  Parsed ( [n, a, h, a] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_7 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_7 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_7 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_7 (max e9 e7)
                pappyAlt7_7 e7 =
                  case testPappys d of
                    Parsed s d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappye d13 of
                                Parsed e d15 e15 ->
                                  Parsed ( [s, e, h, e] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_8 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_8 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_8 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_8 (max e9 e7)
                pappyAlt7_8 e7 =
                  case testPappyt d of
                    Parsed t d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappya d13 of
                                Parsed a d15 e15 ->
                                  Parsed ( [t, o, h, a] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_9 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_9 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_9 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_9 (max e9 e7)
                pappyAlt7_9 e7 =
                  case testPappyg d of
                    Parsed g d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          case testPappyh d11 of
                            Parsed h d13 e13 ->
                              case testPappye d13 of
                                Parsed e d15 e15 ->
                                  Parsed ( [g, a, h, e] ) d15 (maximum [e15,e13,e11,e9,e7])
                                NoParse e15 -> pappyAlt7_10 (maximum [e15,e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_10 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_10 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_10 (max e9 e7)
                pappyAlt7_10 e7 =
                  case testPappyy d of
                    Parsed y d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyy d11 of
                            Parsed y d13 e13 ->
                              Parsed ( [y, h, y] ) d13 (maximum [e13,e11,e9,e7])
                            NoParse e13 -> pappyAlt7_11 (maximum [e13,e11,e9,e7])
                        NoParse e11 -> pappyAlt7_11 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_11 (max e9 e7)
                pappyAlt7_11 e7 =
                  case testPappyb d of
                    Parsed b d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [b, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_12 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_12 (max e9 e7)
                pappyAlt7_12 e7 =
                  case testPappyc d of
                    Parsed c d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [c, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_13 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_13 (max e9 e7)
                pappyAlt7_13 e7 =
                  case testPappyd d of
                    Parsed d d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [d, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_14 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_14 (max e9 e7)
                pappyAlt7_14 e7 =
                  case testPappyf d of
                    Parsed f d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [f, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_15 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_15 (max e9 e7)
                pappyAlt7_15 e7 =
                  case testPappyg d of
                    Parsed g d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [g, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_16 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_16 (max e9 e7)
                pappyAlt7_16 e7 =
                  case testPappyj d of
                    Parsed j d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [j, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_17 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_17 (max e9 e7)
                pappyAlt7_17 e7 =
                  case testPappyk d of
                    Parsed k d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [k, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_18 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_18 (max e9 e7)
                pappyAlt7_18 e7 =
                  case testPappyl d of
                    Parsed l d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [l, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_19 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_19 (max e9 e7)
                pappyAlt7_19 e7 =
                  case testPappym d of
                    Parsed m d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [m, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_20 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_20 (max e9 e7)
                pappyAlt7_20 e7 =
                  case testPappyn d of
                    Parsed n d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [n, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_21 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_21 (max e9 e7)
                pappyAlt7_21 e7 =
                  case testPappyp d of
                    Parsed p d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [p, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_22 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_22 (max e9 e7)
                pappyAlt7_22 e7 =
                  case testPappyr d of
                    Parsed r d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [r, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_23 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_23 (max e9 e7)
                pappyAlt7_23 e7 =
                  case testPappys d of
                    Parsed s d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [s, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_24 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_24 (max e9 e7)
                pappyAlt7_24 e7 =
                  case testPappyt d of
                    Parsed t d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [t, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_25 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_25 (max e9 e7)
                pappyAlt7_25 e7 =
                  case testPappyv d of
                    Parsed v d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [v, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_26 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_26 (max e9 e7)
                pappyAlt7_26 e7 =
                  case testPappyx d of
                    Parsed x d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [x, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_27 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_27 (max e9 e7)
                pappyAlt7_27 e7 =
                  case testPappyz d of
                    Parsed z d9 e9 ->
                      case testPappyy d9 of
                        Parsed y d11 e11 ->
                          Parsed ( [z, y] ) d11 (maximum [e11,e9,e7])
                        NoParse e11 -> pappyAlt7_28 (maximum [e11,e9,e7])
                    NoParse e9 -> pappyAlt7_28 (max e9 e7)
                pappyAlt7_28 e7 = NoParse e7
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyParseCAhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCAhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed caha d3 e3 ->
          Parsed ( caha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [c, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [p, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [n, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [k, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseCAI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCAI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed cai d3 e3 ->
          Parsed ( cai ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [p, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [c, a, i] ) 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 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [c, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [s, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [r, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyCEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyCEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed cei d3 e3 ->
          Parsed ( cei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyc d of
            Parsed c d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [c, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseCEhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCEhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed cehe d3 e3 ->
          Parsed ( cehe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyc d of
            Parsed c d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [c, e, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseCO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed co d3 e3 ->
          Parsed ( co ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyc d of
            Parsed c d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    NoParse e9 ->
                      Parsed ( [c, o] ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseCOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed coi d3 e3 ->
          Parsed ( coi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [j, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [c, o, i] ) 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 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [f, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [t, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [m, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [f, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [c, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [p, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [k, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [n, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [r, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [b, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [j, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [m, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [k, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [v, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_17 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyCU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyCU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed cu d3 e3 ->
          Parsed ( cu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyc d of
            Parsed c d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  Parsed ( [c, u] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseCUhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseCUhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed cuhe d3 e3 ->
          Parsed ( cuhe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [c, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [n, a, u] ) 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
    NoParse e1 -> NoParse e1

testPappyParseDAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseDAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed daho d3 e3 ->
          Parsed ( daho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyd d of
            Parsed d d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [d, a, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyDOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyDOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed doi d3 e3 ->
          Parsed ( doi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyd d of
            Parsed d d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [d, o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseDOhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseDOhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed dohu d3 e3 ->
          Parsed ( dohu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyd d of
            Parsed d d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [d, o, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fa d3 e3 ->
          Parsed ( fa ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [f, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [f, a] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ 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 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [f, e] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [f, o] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [f, u] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [f, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [f, i] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFAhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFAhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed faha d3 e3 ->
          Parsed ( faha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [d, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [b, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [n, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [v, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [g, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [t, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [n, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [c, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [z, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [r, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [r, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [r, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [t, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [b, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [n, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [p, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_17 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [n, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_18 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_18 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [t, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_19 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [z, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_20 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [z, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_21 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_21 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [z, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_22 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [f, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_23 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_23 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed faho d3 e3 ->
          Parsed ( faho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [f, a, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFEhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFEhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fehe d3 e3 ->
          Parsed ( fehe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [f, e, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fehu d3 e3 ->
          Parsed ( fehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [f, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFIhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFIhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fiho d3 e3 ->
          Parsed ( fiho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [f, i, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyFOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyFOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed foi d3 e3 ->
          Parsed ( foi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [f, o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFUhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFUhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fuha d3 e3 ->
          Parsed ( fuha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [f, u, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFUhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFUhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fuhe d3 e3 ->
          Parsed ( fuhe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [f, u, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseFUhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseFUhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed fuho d3 e3 ->
          Parsed ( fuho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyf d of
            Parsed f d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [f, u, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ga d3 e3 ->
          Parsed ( ga ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [g, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [g, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [g, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [g, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [g, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed gaho d3 e3 ->
          Parsed ( gaho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [k, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [g, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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
    NoParse e1 -> NoParse e1

testPappyParseGEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed gehu d3 e3 ->
          Parsed ( gehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyg d of
            Parsed g d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [g, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyGI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyGI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed gi d3 e3 ->
          Parsed ( gi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyg d of
            Parsed g d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  Parsed ( [g, i] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGIhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGIhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed giha d3 e3 ->
          Parsed ( giha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [g, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [g, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [g, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [g, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [g, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed goi d3 e3 ->
          Parsed ( goi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [n, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [n, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [g, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [p, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [p, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [p, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [p, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGOhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGOhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed goha d3 e3 ->
          Parsed ( goha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [m, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [n, e, i] ) 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 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [g, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [g, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [g, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [n, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [g, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [g, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [d, u] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [b, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [b, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [b, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [c, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseGUhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseGUhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed guha d3 e3 ->
          Parsed ( guha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [g, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [g, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [g, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [g, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [g, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed i d3 e3 ->
          Parsed ( i ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyi d of
            Parsed i d5 e5 ->
              Parsed ( [i] ) d5 e5
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseJA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseJA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ja d3 e3 ->
          Parsed ( ja ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [j, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [j, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [j, o] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [j, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [j, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyJAI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyJAI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed jai d3 e3 ->
          Parsed ( jai ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyj d of
            Parsed j d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [j, a, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseJOhI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseJOhI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed johi d3 e3 ->
          Parsed ( johi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyj d of
            Parsed j d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [j, o, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseJOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseJOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed joi d3 e3 ->
          Parsed ( joi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [f, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [p, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [j, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [c, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [c, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [j, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [k, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [j, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [j, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyKE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyKE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ke d3 e3 ->
          Parsed ( ke ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  Parsed ( [k, e] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseKEhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseKEhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed kehe d3 e3 ->
          Parsed ( kehe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [k, e, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyKEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyKEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed kei d3 e3 ->
          Parsed ( kei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [k, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyKI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyKI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ki d3 e3 ->
          Parsed ( ki ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  Parsed ( [k, i] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseKOhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseKOhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed koha d3 e3 ->
          Parsed ( koha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [d, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [d, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [d, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [d, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [d, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [d, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [d, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [d, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [m, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [m, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [m, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [d, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [k, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [f, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [k, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [k, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_17 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [k, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_18 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_18 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [k, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_19 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [f, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_20 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [f, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_21 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_21 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [f, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_22 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [f, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_23 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_23 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [v, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_24 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_24 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_24 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_24 (max e7 e5)
            pappyAlt5_24 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [v, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_25 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_25 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_25 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_25 (max e7 e5)
            pappyAlt5_25 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [v, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_26 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_26 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_26 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_26 (max e7 e5)
            pappyAlt5_26 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [v, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_27 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_27 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_27 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_27 (max e7 e5)
            pappyAlt5_27 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [v, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_28 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_28 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_28 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_28 (max e7 e5)
            pappyAlt5_28 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [r, u] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_29 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_29 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_29 (max e7 e5)
            pappyAlt5_29 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [r, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_30 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_30 (max e7 e5)
            pappyAlt5_30 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [r, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_31 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_31 (max e7 e5)
            pappyAlt5_31 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [t, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_32 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_32 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_32 (max e7 e5)
            pappyAlt5_32 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [t, u] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_33 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_33 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_33 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_33 (max e7 e5)
            pappyAlt5_33 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [t, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_34 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_34 (max e7 e5)
            pappyAlt5_34 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [z, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_35 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_35 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_35 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_35 (max e7 e5)
            pappyAlt5_35 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [k, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_36 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_36 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_36 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_36 (max e7 e5)
            pappyAlt5_36 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [m, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_37 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_37 (max e7 e5)
            pappyAlt5_37 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [z, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_38 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_38 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_38 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_38 (max e7 e5)
            pappyAlt5_38 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [z, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_39 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_39 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_39 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_39 (max e7 e5)
            pappyAlt5_39 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [c, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_40 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_40 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_40 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_40 (max e7 e5)
            pappyAlt5_40 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [d, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_41 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_41 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_41 (max e7 e5)
            pappyAlt5_41 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [d, e] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_42 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_42 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_42 (max e7 e5)
            pappyAlt5_42 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [d, i] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_43 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_43 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_43 (max e7 e5)
            pappyAlt5_43 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [k, o] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_44 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_44 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_44 (max e7 e5)
            pappyAlt5_44 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [m, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_45 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_45 (max e7 e5)
            pappyAlt5_45 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [d, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_46 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_46 (max e7 e5)
            pappyAlt5_46 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseKU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseKU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ku d3 e3 ->
          Parsed ( ku ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    NoParse e9 ->
                      Parsed ( [k, u] ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseKUhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseKUhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed kuhe d3 e3 ->
          Parsed ( kuhe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [k, u, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseKUhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseKUhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed kuho d3 e3 ->
          Parsed ( kuho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyk d of
            Parsed k d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [k, u, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed la d3 e3 ->
          Parsed ( la ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [l, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [l, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [l, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLAU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLAU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lau d3 e3 ->
          Parsed ( lau ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [c, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [l, a, u] ) 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 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [z, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [t, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLAhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLAhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lahe d3 e3 ->
          Parsed ( lahe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [t, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [l, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [l, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [l, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [v, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [l, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [l, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed le d3 e3 ->
          Parsed ( le ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [l, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [l, o, i] ) 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 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [l, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [l, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [l, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [l, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [l, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [l, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lehu d3 e3 ->
          Parsed ( lehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [l, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed li d3 e3 ->
          Parsed ( li ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [m, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [l, i] ) 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

testPappyParseLIhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLIhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lihu d3 e3 ->
          Parsed ( lihu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [l, i, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLOhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLOhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed loho d3 e3 ->
          Parsed ( loho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [l, o, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLOhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLOhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lohu d3 e3 ->
          Parsed ( lohu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [l, o, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyLU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyLU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed lu d3 e3 ->
          Parsed ( lu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  Parsed ( [l, u] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseLUhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseLUhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed luhu d3 e3 ->
          Parsed ( luhu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyl d of
            Parsed l d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [l, u, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed maho d3 e3 ->
          Parsed ( maho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappym d of
            Parsed m d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [m, a, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMAI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMAI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed mai d3 e3 ->
          Parsed ( mai ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [m, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [m, a, i] ) 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
    NoParse e1 -> NoParse e1

testPappyME :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyME d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed me d3 e3 ->
          Parsed ( me ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappym d of
            Parsed m d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  Parsed ( [m, e] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed mehu d3 e3 ->
          Parsed ( mehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappym d of
            Parsed m d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [m, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMOhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMOhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed mohe d3 e3 ->
          Parsed ( mohe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappym d of
            Parsed m d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [m, o, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMOhI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMOhI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed mohi d3 e3 ->
          Parsed ( mohi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappym d of
            Parsed m d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [m, o, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseMOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseMOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed moi d3 e3 ->
          Parsed ( moi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [m, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [m, o, i] ) 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 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [s, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [c, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [v, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed na d3 e3 ->
          Parsed ( na ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [j, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [n, a] ) 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

testPappyNAI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyNAI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nai d3 e3 ->
          Parsed ( nai ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [n, a, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNAhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNAhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nahe d3 e3 ->
          Parsed ( nahe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [t, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [j, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [n, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [n, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNAhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNAhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nahu d3 e3 ->
          Parsed ( nahu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [n, a, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNIhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNIhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nihe d3 e3 ->
          Parsed ( nihe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [n, i, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNIhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNIhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed niho d3 e3 ->
          Parsed ( niho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [n, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [n, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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
    NoParse e1 -> NoParse e1

testPappyParseNOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed noi d3 e3 ->
          Parsed ( noi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [v, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [n, o, i] ) 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 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [p, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nu d3 e3 ->
          Parsed ( nu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [n, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [d, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [s, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [n, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [l, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [k, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_7 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_7 (max e7 e5)
            pappyAlt5_7 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [j, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [s, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [z, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [m, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [p, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [z, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNUhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNUhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nuha d3 e3 ->
          Parsed ( nuha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [n, u, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNUhI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNUhI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nuhi d3 e3 ->
          Parsed ( nuhi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [n, u, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseNUhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseNUhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed nuhu d3 e3 ->
          Parsed ( nuhu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyn d of
            Parsed n d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [n, u, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsePA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed pa d3 e3 ->
          Parsed ( pa ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [d, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [f, e, i] ) 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 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [g, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [j, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [r, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [v, a, i] ) 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)
            pappyAlt5_7 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [p, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [p, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [f, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [z, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [m, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [n, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [k, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [c, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [m, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [r, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_17 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [d, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_18 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_18 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [s, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_19 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [j, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_20 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [s, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_21 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_21 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [s, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_22 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyvowel d9 of
                        NoParse e11 ->
                          Parsed ( [r, o] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_23 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [r, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_24 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_24 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_24 (max e7 e5)
            pappyAlt5_24 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [s, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_25 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_25 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_25 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_25 (max e7 e5)
            pappyAlt5_25 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [s, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_26 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_26 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_26 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_26 (max e7 e5)
            pappyAlt5_26 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [s, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_27 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_27 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_27 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_27 (max e7 e5)
            pappyAlt5_27 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [s, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_28 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_28 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_28 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_28 (max e7 e5)
            pappyAlt5_28 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [m, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_29 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_29 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_29 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_29 (max e7 e5)
            pappyAlt5_29 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [d, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_30 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_30 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_30 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_30 (max e7 e5)
            pappyAlt5_30 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [t, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_31 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_31 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_31 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_31 (max e7 e5)
            pappyAlt5_31 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [k, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_32 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_32 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_32 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_32 (max e7 e5)
            pappyAlt5_32 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [c, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_33 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_33 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_33 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_33 (max e7 e5)
            pappyAlt5_33 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [t, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_34 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_34 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_34 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_34 (max e7 e5)
            pappyAlt5_34 e5 =
              case testPappyx d of
                Parsed x d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [x, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_35 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_35 (max e7 e5)
            pappyAlt5_35 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [p, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_36 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_36 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_36 (max e7 e5)
            pappyAlt5_36 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [n, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_37 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_37 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_37 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_37 (max e7 e5)
            pappyAlt5_37 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [n, o] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_38 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_38 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_38 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_38 (max e7 e5)
            pappyAlt5_38 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [p, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_39 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_39 (max e7 e5)
            pappyAlt5_39 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [r, e] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_40 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_40 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_40 (max e7 e5)
            pappyAlt5_40 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [c, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_41 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_41 (max e7 e5)
            pappyAlt5_41 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [v, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_42 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_42 (max e7 e5)
            pappyAlt5_42 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [m, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_43 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_43 (max e7 e5)
            pappyAlt5_43 e5 =
              case testPappyx d of
                Parsed x d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [x, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_44 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_44 (max e7 e5)
            pappyAlt5_44 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [z, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_45 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_45 (max e7 e5)
            pappyAlt5_45 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [b, i] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_46 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_46 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_46 (max e7 e5)
            pappyAlt5_46 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [s, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_47 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_47 (max e7 e5)
            pappyAlt5_47 e5 =
              case testPappydigit d of
                Parsed d d7 e7 ->
                  Parsed ( [d] ) d7 (max e7 e5)
                NoParse e7 -> pappyAlt5_48 (max e7 e5)
            pappyAlt5_48 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePEhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsePEhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed pehe d3 e3 ->
          Parsed ( pehe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyp d of
            Parsed p d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [p, e, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePEhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsePEhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed peho d3 e3 ->
          Parsed ( peho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyp d of
            Parsed p d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [p, e, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParsePU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed pu d3 e3 ->
          Parsed ( pu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [b, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [p, u] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ 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 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [c, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseRAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseRAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed raho d3 e3 ->
          Parsed ( raho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyr d of
            Parsed r d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [r, a, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseROI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseROI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed roi d3 e3 ->
          Parsed ( roi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [r, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [r, o, i] ) 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
    NoParse e1 -> NoParse e1

testPappySA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappySA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed sa d3 e3 ->
          Parsed ( sa ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappys d of
            Parsed s d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  Parsed ( [s, a] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseSE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseSE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed se d3 e3 ->
          Parsed ( se ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [s, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [t, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [v, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyx d of
                Parsed x d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [x, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseSEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseSEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed sei d3 e3 ->
          Parsed ( sei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [s, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [t, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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
    NoParse e1 -> NoParse e1

testPappyParseSEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseSEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed sehu d3 e3 ->
          Parsed ( sehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappys d of
            Parsed s d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [s, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseSI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseSI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed si d3 e3 ->
          Parsed ( si ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappys d of
            Parsed s d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    NoParse e9 ->
                      case testPappyvowel d7 of
                        NoParse e11 ->
                          Parsed ( [s, i] ) d7 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> NoParse (maximum [e11,e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappySOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappySOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed soi d3 e3 ->
          Parsed ( soi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappys d of
            Parsed s d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [s, o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseSU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseSU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed su d3 e3 ->
          Parsed ( su ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappys d of
            Parsed s d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    NoParse e9 ->
                      Parsed ( [s, u] ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseTAhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseTAhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed tahe d3 e3 ->
          Parsed ( tahe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [r, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [t, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [d, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [n, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseTEhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseTEhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed tehu d3 e3 ->
          Parsed ( tehu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyt d of
            Parsed t d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [t, e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyTEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyTEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed tei d3 e3 ->
          Parsed ( tei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyt d of
            Parsed t d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [t, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseTO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseTO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed to d3 e3 ->
          Parsed ( to ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [t, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          case testPappyvowel d9 of
                            NoParse e13 ->
                              Parsed ( [t, o] ) d9 (maximum [e13,e11,e9,e7,e5])
                            Parsed _ _ e13 -> pappyAlt5_3 (maximum [e13,e11,e9,e7,e5])
                        Parsed _ _ 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
    NoParse e1 -> NoParse e1

testPappyTOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyTOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed toi d3 e3 ->
          Parsed ( toi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyt d of
            Parsed t d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [t, o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseTUhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseTUhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed tuhe d3 e3 ->
          Parsed ( tuhe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyt d of
            Parsed t d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [t, u, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseTUhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseTUhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed tuhu d3 e3 ->
          Parsed ( tuhu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyt d of
            Parsed t d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [t, u, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseUI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseUI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed ui d3 e3 ->
          Parsed ( ui ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [i, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [i, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_3 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_3 (max e7 e5)
            pappyAlt5_3 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [a, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [u, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [i, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [i, h, e] ) 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)
            pappyAlt5_7 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [a, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [i, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [o, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [o, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [e, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [o, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [u, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [e, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [u, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [a, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      Parsed ( [u, a] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [a, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [i, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [i, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [u, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [u, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [a, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_24 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_24 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_24 (max e7 e5)
            pappyAlt5_24 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [a, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_25 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_25 (max e7 e5)
            pappyAlt5_25 e5 =
              case testPappya d of
                Parsed a d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [a, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_26 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_26 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_26 (max e7 e5)
            pappyAlt5_26 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [i, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_27 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_27 (max e7 e5)
            pappyAlt5_27 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_28 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_28 (max e7 e5)
            pappyAlt5_28 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [o, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_29 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_29 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_29 (max e7 e5)
            pappyAlt5_29 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [e, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_30 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_30 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_30 (max e7 e5)
            pappyAlt5_30 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [u, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_31 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_31 (max e7 e5)
            pappyAlt5_31 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappya d9 of
                        Parsed a d11 e11 ->
                          Parsed ( [o, h, a] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_32 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_32 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_32 (max e7 e5)
            pappyAlt5_32 e5 =
              case testPappyo d of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [o, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_33 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_33 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_33 (max e7 e5)
            pappyAlt5_33 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [u, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_34 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_34 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_34 (max e7 e5)
            pappyAlt5_34 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [e, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_35 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_35 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_35 (max e7 e5)
            pappyAlt5_35 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      Parsed ( [i, o] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_36 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_36 (max e7 e5)
            pappyAlt5_36 e5 =
              case testPappye d of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [e, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_37 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_37 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_37 (max e7 e5)
            pappyAlt5_37 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      Parsed ( [u, e] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_38 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_38 (max e7 e5)
            pappyAlt5_38 e5 =
              case testPappyi d of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [i, h, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_39 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_39 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_39 (max e7 e5)
            pappyAlt5_39 e5 =
              case testPappyu d of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [u, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_40 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_40 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_40 (max e7 e5)
            pappyAlt5_40 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [b, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_41 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_41 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_41 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_41 (max e7 e5)
            pappyAlt5_41 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [j, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_42 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_42 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_42 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_42 (max e7 e5)
            pappyAlt5_42 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [c, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_43 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_43 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_43 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_43 (max e7 e5)
            pappyAlt5_43 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [s, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_44 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_44 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_44 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_44 (max e7 e5)
            pappyAlt5_44 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [t, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_45 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_45 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_45 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_45 (max e7 e5)
            pappyAlt5_45 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [k, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_46 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_46 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_46 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_46 (max e7 e5)
            pappyAlt5_46 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [s, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_47 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_47 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_47 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_47 (max e7 e5)
            pappyAlt5_47 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [z, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_48 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_48 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_48 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_48 (max e7 e5)
            pappyAlt5_48 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [p, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_49 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_49 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_49 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_49 (max e7 e5)
            pappyAlt5_49 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [r, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_50 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_50 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_50 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_50 (max e7 e5)
            pappyAlt5_50 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [j, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_51 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_51 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_51 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_51 (max e7 e5)
            pappyAlt5_51 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [t, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_52 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_52 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_52 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_52 (max e7 e5)
            pappyAlt5_52 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [r, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_53 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_53 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_53 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_53 (max e7 e5)
            pappyAlt5_53 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [l, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_54 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_54 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_54 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_54 (max e7 e5)
            pappyAlt5_54 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [b, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_55 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_55 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_55 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_55 (max e7 e5)
            pappyAlt5_55 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [m, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_56 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_56 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_56 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_56 (max e7 e5)
            pappyAlt5_56 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [d, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_57 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_57 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_57 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_57 (max e7 e5)
            pappyAlt5_57 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [t, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_58 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_58 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_58 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_58 (max e7 e5)
            pappyAlt5_58 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [v, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_59 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_59 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_59 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_59 (max e7 e5)
            pappyAlt5_59 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [p, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_60 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_60 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_60 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_60 (max e7 e5)
            pappyAlt5_60 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [z, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_61 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_61 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_61 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_61 (max e7 e5)
            pappyAlt5_61 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [s, a, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_62 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_62 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_62 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_62 (max e7 e5)
            pappyAlt5_62 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [l, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_63 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_63 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_63 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_63 (max e7 e5)
            pappyAlt5_63 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [k, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_64 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_64 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_64 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_64 (max e7 e5)
            pappyAlt5_64 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [s, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_65 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_65 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_65 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_65 (max e7 e5)
            pappyAlt5_65 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [d, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_66 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_66 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_66 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_66 (max e7 e5)
            pappyAlt5_66 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [j, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_67 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_67 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_67 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_67 (max e7 e5)
            pappyAlt5_67 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [s, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_68 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_68 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_68 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_68 (max e7 e5)
            pappyAlt5_68 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [k, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_69 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_69 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_69 (max e7 e5)
            pappyAlt5_69 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [t, a, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_70 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_70 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_70 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_70 (max e7 e5)
            pappyAlt5_70 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [n, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_71 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_71 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_71 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_71 (max e7 e5)
            pappyAlt5_71 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [j, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_72 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_72 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_72 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_72 (max e7 e5)
            pappyAlt5_72 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [b, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_73 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_73 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_73 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_73 (max e7 e5)
            pappyAlt5_73 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [l, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_74 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_74 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_74 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_74 (max e7 e5)
            pappyAlt5_74 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [p, a, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_75 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_75 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_75 (max e7 e5)
            pappyAlt5_75 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [m, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_76 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_76 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_76 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_76 (max e7 e5)
            pappyAlt5_76 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [k, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_77 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_77 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_77 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_77 (max e7 e5)
            pappyAlt5_77 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [j, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_78 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_78 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_78 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_78 (max e7 e5)
            pappyAlt5_78 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [s, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_79 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_79 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_79 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_79 (max e7 e5)
            pappyAlt5_79 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [p, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_80 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_80 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_80 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_80 (max e7 e5)
            pappyAlt5_80 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [p, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_81 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_81 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_81 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_81 (max e7 e5)
            pappyAlt5_81 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [r, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_82 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_82 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_82 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_82 (max e7 e5)
            pappyAlt5_82 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [r, o, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_83 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_83 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_83 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_83 (max e7 e5)
            pappyAlt5_83 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [r, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_84 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_84 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_84 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_84 (max e7 e5)
            pappyAlt5_84 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [r, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_85 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_85 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_85 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_85 (max e7 e5)
            pappyAlt5_85 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [r, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_86 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_86 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_86 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_86 (max e7 e5)
            pappyAlt5_86 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [r, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_87 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_87 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_87 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_87 (max e7 e5)
            pappyAlt5_87 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [l, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_88 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_88 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_88 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_88 (max e7 e5)
            pappyAlt5_88 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [j, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_89 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_89 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_89 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_89 (max e7 e5)
            pappyAlt5_89 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [f, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_90 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_90 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_90 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_90 (max e7 e5)
            pappyAlt5_90 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [d, a, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_91 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_91 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_91 (max e7 e5)
            pappyAlt5_91 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [g, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_92 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_92 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_92 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_92 (max e7 e5)
            pappyAlt5_92 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [z, o, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_93 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_93 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_93 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_93 (max e7 e5)
            pappyAlt5_93 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [b, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_94 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_94 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_94 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_94 (max e7 e5)
            pappyAlt5_94 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [r, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_95 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_95 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_95 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_95 (max e7 e5)
            pappyAlt5_95 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [s, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_96 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_96 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_96 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_96 (max e7 e5)
            pappyAlt5_96 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [s, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_97 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_97 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_97 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_97 (max e7 e5)
            pappyAlt5_97 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [v, u, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_98 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_98 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_98 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_98 (max e7 e5)
            pappyAlt5_98 e5 =
              case testPappyk d of
                Parsed k d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [k, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_99 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_99 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_99 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_99 (max e7 e5)
            pappyAlt5_99 e5 =
              case testPappyx d of
                Parsed x d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [x, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> pappyAlt5_100 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_100 (max e7 e5)
            pappyAlt5_100 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [g, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_101 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_101 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_101 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_101 (max e7 e5)
            pappyAlt5_101 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [b, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_102 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_102 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_102 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_102 (max e7 e5)
            pappyAlt5_102 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed va d3 e3 ->
          Parsed ( va ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [v, i] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [v, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ 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 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [v, u] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyVAU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyVAU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed vau d3 e3 ->
          Parsed ( vau ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyv d of
            Parsed v d5 e5 ->
              case testPappya d5 of
                Parsed a d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      Parsed ( [v, a, u] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyVEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyVEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed vei d3 e3 ->
          Parsed ( vei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyv d of
            Parsed v d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [v, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVEhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVEhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed veho d3 e3 ->
          Parsed ( veho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyv d of
            Parsed v d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [v, e, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVUhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVUhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed vuhu d3 e3 ->
          Parsed ( vuhu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [g, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [f, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [p, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [f, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [v, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [s, u, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyj d of
                Parsed j d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [j, u, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyg d of
                Parsed g d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [g, e, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [p, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [f, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 =
              case testPappyt d of
                Parsed t d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [t, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_12 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_12 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_12 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_12 (max e7 e5)
            pappyAlt5_12 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [c, u, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_13 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_13 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_13 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_13 (max e7 e5)
            pappyAlt5_13 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [v, a, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_14 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_14 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_14 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_14 (max e7 e5)
            pappyAlt5_14 e5 =
              case testPappyn d of
                Parsed n d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [n, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_15 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_15 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_15 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_15 (max e7 e5)
            pappyAlt5_15 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [d, e, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_16 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_16 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_16 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_16 (max e7 e5)
            pappyAlt5_16 e5 =
              case testPappyf d of
                Parsed f d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [f, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_17 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_17 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_17 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_17 (max e7 e5)
            pappyAlt5_17 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [s, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_18 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_18 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_18 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_18 (max e7 e5)
            pappyAlt5_18 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [r, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_19 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_19 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_19 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_19 (max e7 e5)
            pappyAlt5_19 e5 =
              case testPappyr d of
                Parsed r d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [r, i, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_20 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_20 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_20 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_20 (max e7 e5)
            pappyAlt5_20 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [s, a, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_21 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_21 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_21 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_21 (max e7 e5)
            pappyAlt5_21 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [p, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_22 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_22 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_22 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_22 (max e7 e5)
            pappyAlt5_22 e5 =
              case testPappys d of
                Parsed s d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [s, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_23 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_23 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_23 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_23 (max e7 e5)
            pappyAlt5_23 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVEhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVEhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed veha d3 e3 ->
          Parsed ( veha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [v, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [v, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [v, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [v, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVIhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVIhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed viha d3 e3 ->
          Parsed ( viha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [v, i, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [v, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [v, i, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyv d of
                Parsed v d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [v, i, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseVUhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseVUhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed vuho d3 e3 ->
          Parsed ( vuho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyv d of
            Parsed v d5 e5 ->
              case testPappyu d5 of
                Parsed u d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyo d9 of
                        Parsed o d11 e11 ->
                          Parsed ( [v, u, h, o] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyXI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyXI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed xi d3 e3 ->
          Parsed ( xi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyx d of
            Parsed x d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  Parsed ( [x, i] ) d7 (max e7 e5)
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsePlusRule24 :: TestPappyDerivs -> Result TestPappyDerivs ([Char])
testPappyParsePlusRule24 d =
  pappyAlt1_1 (ParseError (testPappyPos d) []) where
    pappyAlt1_1 e1 =
      case testPappyy d of
        Parsed v d3 e3 ->
          case testPappyPlusRule24 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 testPappyy d of
        Parsed v d3 e3 ->
          Parsed ([v]) d3 (max e3 e1)
        NoParse e3 -> pappyAlt1_3 (max e3 e1)
    pappyAlt1_3 e1 = NoParse e1

testPappyY :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyY d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case testPappyPlusRule24 d of
        Parsed y d3 e3 ->
          case testPappypost_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

testPappyParseZAhO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZAhO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zaho d3 e3 ->
          Parsed ( zaho ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [c, o, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyp d of
                Parsed p d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [p, u, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [c, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappym d of
                Parsed m d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [m, o, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [c, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_6 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_6 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_6 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_6 (max e7 e5)
            pappyAlt5_6 e5 =
              case testPappyc d of
                Parsed c d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [c, o, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_7 (maximum [e13,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)
            pappyAlt5_7 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [d, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_8 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_8 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_8 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_8 (max e7 e5)
            pappyAlt5_8 e5 =
              case testPappyb d of
                Parsed b d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [b, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_9 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_9 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_9 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_9 (max e7 e5)
            pappyAlt5_9 e5 =
              case testPappyd d of
                Parsed d d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [d, i, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_10 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_10 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_10 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_10 (max e7 e5)
            pappyAlt5_10 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [z, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_11 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_11 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_11 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_11 (max e7 e5)
            pappyAlt5_11 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseZEhA :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZEhA d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zeha d3 e3 ->
          Parsed ( zeha ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyu d11 of
                            Parsed u d13 e13 ->
                              Parsed ( [z, e, h, u] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_2 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappya d11 of
                            Parsed a d13 e13 ->
                              Parsed ( [z, e, h, a] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyi d11 of
                            Parsed i d13 e13 ->
                              Parsed ( [z, e, h, i] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_4 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappye d7 of
                    Parsed e d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappye d11 of
                            Parsed e d13 e13 ->
                              Parsed ( [z, e, h, e] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_5 (maximum [e13,e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_5 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_5 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_5 (max e7 e5)
            pappyAlt5_5 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyZEI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyZEI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zei d3 e3 ->
          Parsed ( zei ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyz d of
            Parsed z d5 e5 ->
              case testPappye d5 of
                Parsed e d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      Parsed ( [z, e, i] ) d9 (maximum [e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseZI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zi d3 e3 ->
          Parsed ( zi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyu d7 of
                    Parsed u d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [z, u] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [z, a] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ 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 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyi d7 of
                    Parsed i d9 e9 ->
                      case testPappyh d9 of
                        NoParse e11 ->
                          Parsed ( [z, i] ) d9 (maximum [e11,e9,e7,e5])
                        Parsed _ _ e11 -> pappyAlt5_4 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_4 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_4 (max e7 e5)
            pappyAlt5_4 e5 = NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseZIhE :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZIhE d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zihe d3 e3 ->
          Parsed ( zihe ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyz d of
            Parsed z d5 e5 ->
              case testPappyi d5 of
                Parsed i d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappye d9 of
                        Parsed e d11 e11 ->
                          Parsed ( [z, i, h, e] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyZO :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyZO d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zo d3 e3 ->
          Parsed ( zo ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyz d of
            Parsed z d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyi d7 of
                    NoParse e9 ->
                      Parsed ( [z, o] ) d7 (maximum [e9,e7,e5])
                    Parsed _ _ e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParseZOI :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZOI d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zoi d3 e3 ->
          Parsed ( zoi ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (testPappyPos d) []) where
            pappyAlt5_1 e5 =
              case testPappyz d of
                Parsed z d7 e7 ->
                  case testPappyo d7 of
                    Parsed o d9 e9 ->
                      case testPappyi d9 of
                        Parsed i d11 e11 ->
                          Parsed ( [z, o, i] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> pappyAlt5_2 (maximum [e11,e9,e7,e5])
                    NoParse e9 -> pappyAlt5_2 (maximum [e9,e7,e5])
                NoParse e7 -> pappyAlt5_2 (max e7 e5)
            pappyAlt5_2 e5 =
              case testPappyl d of
                Parsed l d7 e7 ->
                  case testPappya d7 of
                    Parsed a d9 e9 ->
                      case testPappyh d9 of
                        Parsed h d11 e11 ->
                          case testPappyo d11 of
                            Parsed o d13 e13 ->
                              Parsed ( [l, a, h, o] ) d13 (maximum [e13,e11,e9,e7,e5])
                            NoParse e13 -> pappyAlt5_3 (maximum [e13,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
    NoParse e1 -> NoParse e1

testPappyParseZOhU :: TestPappyDerivs -> Result TestPappyDerivs (String)
testPappyParseZOhU d =
  case testPappycmavo d of
    Parsed _ _ e1 ->
      case pappyResult3 of
        Parsed zohu d3 e3 ->
          Parsed ( zohu ) d3 (max e3 e1)
        NoParse e3 -> NoParse (max e3 e1)
      where
        pappyResult3 =
          case testPappyz d of
            Parsed z d5 e5 ->
              case testPappyo d5 of
                Parsed o d7 e7 ->
                  case testPappyh d7 of
                    Parsed h d9 e9 ->
                      case testPappyu d9 of
                        Parsed u d11 e11 ->
                          Parsed ( [z, o, h, u] ) d11 (maximum [e11,e9,e7,e5])
                        NoParse e11 -> NoParse (maximum [e11,e9,e7,e5])
                    NoParse e9 -> NoParse (maximum [e9,e7,e5])
                NoParse e7 -> NoParse (max e7 e5)
            NoParse e5 -> NoParse e5
    NoParse e1 -> NoParse e1

testPappyParsedummyTail :: TestPappyDerivs -> Result TestPappyDerivs ((() -> ()))
testPappyParsedummyTail d =
  case testPappyChar d of
    Parsed 'a' d1 _ ->
      case testPappydummy d1 of
        Parsed _ d3 e3 ->
          case testPappydummyTail 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 (testPappyPos d) [])

testPappyParsedummy :: TestPappyDerivs -> Result TestPappyDerivs (())
testPappyParsedummy d =
  case pappyResult1 of
    Parsed l d1 e1 ->
      case testPappydummyTail 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 testPappyChar d of
        Parsed 'a' d3 _ ->
          case testPappydummy d3 of
            Parsed _ d5 e5 ->
              Parsed ( () ) d5 e5
            NoParse e5 -> NoParse e5
        _ -> NoParse (ParseError (testPappyPos d) [])