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

import Pappy.Pos
import Pappy.Parse
import Pappy.Basic

{-# LINE 17 "Morphology.pappy" #-}
import Data.Maybe


{-# LINE 521 "Morphology.pappy" #-}

data MorphologyDerivs = MorphologyDerivs {
	morphologySub0 :: MorphologyDerivs0,
	morphologySub1 :: MorphologyDerivs1,
	morphologySub2 :: MorphologyDerivs2,
	morphologySub3 :: MorphologyDerivs3,
	morphologyChar :: Result MorphologyDerivs Char,
	morphologyPos :: Pos
}

instance Derivs MorphologyDerivs where
	dvChar d = morphologyChar d
	dvPos d = morphologyPos d

data MorphologyDerivs0 = MorphologyDerivs0 {
	morphologySubStarRule0 :: Result MorphologyDerivs ([String]),
	morphologySublojban_word :: Result MorphologyDerivs (String),
	morphologySubStarRule1 :: Result MorphologyDerivs ([String]),
	morphologySubzifcme :: Result MorphologyDerivs (String),
	morphologySubPlusRule0 :: Result MorphologyDerivs ([String]),
	morphologySubcmavo :: Result MorphologyDerivs (String),
	morphologySubStarRule3 :: Result MorphologyDerivs ([String]),
	morphologySubStarRule4 :: Result MorphologyDerivs ([String]),
	morphologySubstressed_extended_rafsi :: Result MorphologyDerivs (String),
	morphologySubextended_rafsi :: Result MorphologyDerivs (String),
	morphologySubStarRule6 :: Result MorphologyDerivs ([String]),
	morphologySubStarRule7 :: Result MorphologyDerivs ([String]),
	morphologySubbrivla_head :: Result MorphologyDerivs (String),
	morphologySubStarRule8 :: Result MorphologyDerivs ([String]),
	morphologySubgismu :: Result MorphologyDerivs (String),
	morphologySubCVV_final_rafsi :: Result MorphologyDerivs (String)}

data MorphologyDerivs1 = MorphologyDerivs1 {
	morphologySubshort_final_rafsi :: Result MorphologyDerivs (String),
	morphologySubstressed_y_rafsi :: Result MorphologyDerivs (String),
	morphologySubstressed_y_less_rafsi :: Result MorphologyDerivs (String),
	morphologySuby_rafsi :: Result MorphologyDerivs (String),
	morphologySuby_less_rafsi :: Result MorphologyDerivs (String),
	morphologySubr_hyphen :: Result MorphologyDerivs (String),
	morphologySubfinal_syllable :: Result MorphologyDerivs (String),
	morphologySubstressed_syllable :: Result MorphologyDerivs (String),
	morphologySubstressed_vowel :: Result MorphologyDerivs (String),
	morphologySubunstressed_syllable :: Result MorphologyDerivs (String),
	morphologySubStarRule9 :: Result MorphologyDerivs ([String]),
	morphologySubconsonantal_syllable :: Result MorphologyDerivs (String),
	morphologySubcoda :: Result MorphologyDerivs (String),
	morphologySubonset :: Result MorphologyDerivs (String),
	morphologySubnucleus :: Result MorphologyDerivs (String)}

data MorphologyDerivs2 = MorphologyDerivs2 {
	morphologySubglide :: Result MorphologyDerivs (String),
	morphologySubdiphthong :: Result MorphologyDerivs (String),
	morphologySubvowel :: Result MorphologyDerivs (String),
	morphologySubPlusRule2 :: Result MorphologyDerivs ([String]),
	morphologySubinitial_pair :: Result MorphologyDerivs (String),
	morphologySubinitial :: Result MorphologyDerivs (String),
	morphologySubl :: Result MorphologyDerivs (String),
	morphologySubm :: Result MorphologyDerivs (String),
	morphologySubn :: Result MorphologyDerivs (String),
	morphologySubr :: Result MorphologyDerivs (String),
	morphologySubb :: Result MorphologyDerivs (String),
	morphologySubd :: Result MorphologyDerivs (String),
	morphologySubg :: Result MorphologyDerivs (String),
	morphologySubv :: Result MorphologyDerivs (String),
	morphologySubj :: Result MorphologyDerivs (String)}

data MorphologyDerivs3 = MorphologyDerivs3 {
	morphologySubz :: Result MorphologyDerivs (String),
	morphologySubs :: Result MorphologyDerivs (String),
	morphologySubc :: Result MorphologyDerivs (String),
	morphologySubx :: Result MorphologyDerivs (String),
	morphologySubk :: Result MorphologyDerivs (String),
	morphologySubf :: Result MorphologyDerivs (String),
	morphologySubp :: Result MorphologyDerivs (String),
	morphologySubt :: Result MorphologyDerivs (String),
	morphologySubPlusRule3 :: Result MorphologyDerivs ([String]),
	morphologySubPlusRule4 :: Result MorphologyDerivs ([String]),
	morphologySubPlusRule5 :: Result MorphologyDerivs ([String]),
	morphologySubStarRule37 :: Result MorphologyDerivs ([String]),
	morphologySubStarRule38 :: Result MorphologyDerivs ([String]),
	morphologySubybu :: Result MorphologyDerivs (String),
	morphologySubPlusRule6 :: Result MorphologyDerivs ([String])}

morphologyStarRule0 = morphologySubStarRule0 . morphologySub0
morphologylojban_word = morphologySublojban_word . morphologySub0
morphologyStarRule1 = morphologySubStarRule1 . morphologySub0
morphologyzifcme = morphologySubzifcme . morphologySub0
morphologyPlusRule0 = morphologySubPlusRule0 . morphologySub0
morphologycmavo = morphologySubcmavo . morphologySub0
morphologyStarRule3 = morphologySubStarRule3 . morphologySub0
morphologyStarRule4 = morphologySubStarRule4 . morphologySub0
morphologystressed_extended_rafsi = morphologySubstressed_extended_rafsi . morphologySub0
morphologyextended_rafsi = morphologySubextended_rafsi . morphologySub0
morphologyStarRule6 = morphologySubStarRule6 . morphologySub0
morphologyStarRule7 = morphologySubStarRule7 . morphologySub0
morphologybrivla_head = morphologySubbrivla_head . morphologySub0
morphologyStarRule8 = morphologySubStarRule8 . morphologySub0
morphologygismu = morphologySubgismu . morphologySub0
morphologyCVV_final_rafsi = morphologySubCVV_final_rafsi . morphologySub0
morphologyshort_final_rafsi = morphologySubshort_final_rafsi . morphologySub1
morphologystressed_y_rafsi = morphologySubstressed_y_rafsi . morphologySub1
morphologystressed_y_less_rafsi = morphologySubstressed_y_less_rafsi . morphologySub1
morphologyy_rafsi = morphologySuby_rafsi . morphologySub1
morphologyy_less_rafsi = morphologySuby_less_rafsi . morphologySub1
morphologyr_hyphen = morphologySubr_hyphen . morphologySub1
morphologyfinal_syllable = morphologySubfinal_syllable . morphologySub1
morphologystressed_syllable = morphologySubstressed_syllable . morphologySub1
morphologystressed_vowel = morphologySubstressed_vowel . morphologySub1
morphologyunstressed_syllable = morphologySubunstressed_syllable . morphologySub1
morphologyStarRule9 = morphologySubStarRule9 . morphologySub1
morphologyconsonantal_syllable = morphologySubconsonantal_syllable . morphologySub1
morphologycoda = morphologySubcoda . morphologySub1
morphologyonset = morphologySubonset . morphologySub1
morphologynucleus = morphologySubnucleus . morphologySub1
morphologyglide = morphologySubglide . morphologySub2
morphologydiphthong = morphologySubdiphthong . morphologySub2
morphologyvowel = morphologySubvowel . morphologySub2
morphologyPlusRule2 = morphologySubPlusRule2 . morphologySub2
morphologyinitial_pair = morphologySubinitial_pair . morphologySub2
morphologyinitial = morphologySubinitial . morphologySub2
morphologyl = morphologySubl . morphologySub2
morphologym = morphologySubm . morphologySub2
morphologyn = morphologySubn . morphologySub2
morphologyr = morphologySubr . morphologySub2
morphologyb = morphologySubb . morphologySub2
morphologyd = morphologySubd . morphologySub2
morphologyg = morphologySubg . morphologySub2
morphologyv = morphologySubv . morphologySub2
morphologyj = morphologySubj . morphologySub2
morphologyz = morphologySubz . morphologySub3
morphologys = morphologySubs . morphologySub3
morphologyc = morphologySubc . morphologySub3
morphologyx = morphologySubx . morphologySub3
morphologyk = morphologySubk . morphologySub3
morphologyf = morphologySubf . morphologySub3
morphologyp = morphologySubp . morphologySub3
morphologyt = morphologySubt . morphologySub3
morphologyPlusRule3 = morphologySubPlusRule3 . morphologySub3
morphologyPlusRule4 = morphologySubPlusRule4 . morphologySub3
morphologyPlusRule5 = morphologySubPlusRule5 . morphologySub3
morphologyStarRule37 = morphologySubStarRule37 . morphologySub3
morphologyStarRule38 = morphologySubStarRule38 . morphologySub3
morphologyybu = morphologySubybu . morphologySub3
morphologyPlusRule6 = morphologySubPlusRule6 . morphologySub3

morphologyParse :: String -> String -> MorphologyDerivs
morphologyParse name text = morphologyDerivs (Pos name 1 1) text

morphologyDerivs :: Pos -> String -> MorphologyDerivs
morphologyDerivs pos text = dvs where
  dvs = MorphologyDerivs
    (morphologyDerivs0 dvs)
    (morphologyDerivs1 dvs)
    (morphologyDerivs2 dvs)
    (morphologyDerivs3 dvs)
    chr pos
  chr = case text of
    [] -> NoParse (msgError (morphologyPos dvs) "end of input")
    (c:cs) -> Parsed c (morphologyDerivs (nextPos pos c) cs) (ParseError pos [])

morphologyDerivs0 dvs = MorphologyDerivs0
	(morphologyParseStarRule0 dvs)
	(morphologyParselojban_word dvs)
	(morphologyParseStarRule1 dvs)
	(morphologyParsezifcme dvs)
	(morphologyParsePlusRule0 dvs)
	(morphologyParsecmavo dvs)
	(morphologyParseStarRule3 dvs)
	(morphologyParseStarRule4 dvs)
	(morphologyParsestressed_extended_rafsi dvs)
	(morphologyParseextended_rafsi dvs)
	(morphologyParseStarRule6 dvs)
	(morphologyParseStarRule7 dvs)
	(morphologyParsebrivla_head dvs)
	(morphologyParseStarRule8 dvs)
	(morphologyParsegismu dvs)
	(morphologyParseCVV_final_rafsi dvs)

morphologyDerivs1 dvs = MorphologyDerivs1
	(morphologyParseshort_final_rafsi dvs)
	(morphologyParsestressed_y_rafsi dvs)
	(morphologyParsestressed_y_less_rafsi dvs)
	(morphologyParsey_rafsi dvs)
	(morphologyParsey_less_rafsi dvs)
	(morphologyParser_hyphen dvs)
	(morphologyParsefinal_syllable dvs)
	(morphologyParsestressed_syllable dvs)
	(morphologyParsestressed_vowel dvs)
	(morphologyParseunstressed_syllable dvs)
	(morphologyParseStarRule9 dvs)
	(morphologyParseconsonantal_syllable dvs)
	(morphologyParsecoda dvs)
	(morphologyParseonset dvs)
	(morphologyParsenucleus dvs)

morphologyDerivs2 dvs = MorphologyDerivs2
	(morphologyParseglide dvs)
	(morphologyParsediphthong dvs)
	(morphologyParsevowel dvs)
	(morphologyParsePlusRule2 dvs)
	(morphologyParseinitial_pair dvs)
	(morphologyParseinitial dvs)
	(morphologyParsel dvs)
	(morphologyParsem dvs)
	(morphologyParsen dvs)
	(morphologyParser dvs)
	(morphologyParseb dvs)
	(morphologyParsed dvs)
	(morphologyParseg dvs)
	(morphologyParsev dvs)
	(morphologyParsej dvs)

morphologyDerivs3 dvs = MorphologyDerivs3
	(morphologyParsez dvs)
	(morphologyParses dvs)
	(morphologyParsec dvs)
	(morphologyParsex dvs)
	(morphologyParsek dvs)
	(morphologyParsef dvs)
	(morphologyParsep dvs)
	(morphologyParset dvs)
	(morphologyParsePlusRule3 dvs)
	(morphologyParsePlusRule4 dvs)
	(morphologyParsePlusRule5 dvs)
	(morphologyParseStarRule37 dvs)
	(morphologyParseStarRule38 dvs)
	(morphologyParseybu dvs)
	(morphologyParsePlusRule6 dvs)


morphologyParseStarRule0 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule0 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed _ pappyDvs5 pappyErr5 ->
              case morphologyStarRule0 pappyDvs5 of
                Parsed vs pappyDvs7 pappyErr7 ->
                  Parsed (
                    v : vs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              case morphologypause pappyDvs3 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
                NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologylojban_word d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologylojban_word d of
                NoParse pappyErr7 ->
                  case morphologyPlusRule4 d of
                    Parsed ss pappyDvs9 pappyErr9 ->
                      Parsed (
                        concat ss) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                Parsed _ _ pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologywords :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologywords d =
  case pappyResult1 of
    Parsed _ pappyDvs1 pappyErr1 ->
      case morphologyStarRule0 pappyDvs1 of
        Parsed ws pappyDvs3 pappyErr3 ->
          Parsed (ws) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      case morphologypause d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
        NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3

morphologyParselojban_word :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParselojban_word d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologycmene d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologycmavo d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      pappyAlt3_1 pappyErr1 where
        pappyAlt3_1 pappyErr3 =
          case morphologygismu d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologyfuhivla d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 =
          case morphologygismu d of
            NoParse pappyErr5 ->
              case morphologyfuhivla d of
                NoParse pappyErr7 ->
                  case morphologycmavo d of
                    NoParse pappyErr9 ->
                      case morphologyStarRule4 d of
                        Parsed ss pappyDvs11 pappyErr11 ->
                          case morphologybrivla_core pappyDvs11 of
                            Parsed s pappyDvs13 pappyErr13 ->
                              Parsed (
                                concat ss++s) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                            NoParse pappyErr13 -> pappyAlt3_4 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                        NoParse pappyErr11 -> pappyAlt3_4 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    Parsed _ _ pappyErr9 -> pappyAlt3_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                Parsed _ _ pappyErr7 -> pappyAlt3_4 (maximum [pappyErr7,pappyErr5,pappyErr3])
            Parsed _ _ pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
        pappyAlt3_4 pappyErr3 = pappyAlt1_4 pappyErr3
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologycmene :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologycmene d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyzifcme d of
        Parsed _ _ pappyErr3 ->
          case morphologyPlusRule0 d of
            Parsed ss pappyDvs5 pappyErr5 ->
              case morphologypause pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  Parsed (
                    concat ss) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyzifcme d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseStarRule1 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule1 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule1 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologynucleus d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyglide d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 =
              case morphologyh d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
            pappyAlt5_4 pappyErr5 =
              case morphologyconsonant d of
                Parsed s pappyDvs7 pappyErr7 ->
                  case morphologypause pappyDvs7 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs7 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    Parsed _ _ pappyErr9 -> pappyAlt5_5 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_5 (max pappyErr7 pappyErr5)
            pappyAlt5_5 pappyErr5 =
              case morphologydigit d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_6 (max pappyErr7 pappyErr5)
            pappyAlt5_6 pappyErr5 = NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsezifcme :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsezifcme d =
  case morphologyh d of
    NoParse pappyErr1 ->
      case morphologyStarRule1 d of
        Parsed ss pappyDvs3 pappyErr3 ->
          case morphologyconsonant pappyDvs3 of
            Parsed s pappyDvs5 pappyErr5 ->
              case morphologypause pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  Parsed (
                    concat ss ++ s) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyParsePlusRule0 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule0 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule0 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyany_syllable d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologydigit d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyany_syllable d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologydigit d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsecmavo :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsecmavo d =
  case morphologycmene d of
    NoParse pappyErr1 ->
      case pappyResult3 of
        NoParse pappyErr3 ->
          case pappyResult5 of
            Parsed s pappyDvs5 pappyErr5 ->
              case morphologypost_word pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  Parsed (s) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (morphologyPos d) []) where
                pappyAlt7_1 pappyErr7 =
                  case morphologyh d of
                    NoParse pappyErr9 ->
                      case morphologycluster d of
                        NoParse pappyErr11 ->
                          case morphologyonset d of
                            Parsed s1 pappyDvs13 pappyErr13 ->
                              case morphologyStarRule3 pappyDvs13 of
                                Parsed ss pappyDvs15 pappyErr15 ->
                                  case pappyResult17 of
                                    Parsed s2 pappyDvs17 pappyErr17 ->
                                      Parsed (
                                        s1++concat ss++s2) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                                    NoParse pappyErr17 -> pappyAlt7_2 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                                  where
                                    pappyResult17 =
                                      pappyAlt19_1 (ParseError (morphologyPos pappyDvs15) []) where
                                        pappyAlt19_1 pappyErr19 =
                                          case morphologystressed pappyDvs15 of
                                            NoParse pappyErr21 ->
                                              case morphologynucleus pappyDvs15 of
                                                Parsed s pappyDvs23 pappyErr23 ->
                                                  Parsed (s) pappyDvs23 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                                NoParse pappyErr23 -> pappyAlt19_2 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                            Parsed _ _ pappyErr21 -> pappyAlt19_2 (max pappyErr21 pappyErr19)
                                        pappyAlt19_2 pappyErr19 =
                                          case morphologynucleus pappyDvs15 of
                                            Parsed s pappyDvs21 pappyErr21 ->
                                              case morphologycluster pappyDvs21 of
                                                NoParse pappyErr23 ->
                                                  Parsed (s) pappyDvs21 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                                Parsed _ _ pappyErr23 -> pappyAlt19_3 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                            NoParse pappyErr21 -> pappyAlt19_3 (max pappyErr21 pappyErr19)
                                        pappyAlt19_3 pappyErr19 = NoParse pappyErr19
                                NoParse pappyErr15 -> pappyAlt7_2 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                            NoParse pappyErr13 -> pappyAlt7_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                        Parsed _ _ pappyErr11 -> pappyAlt7_2 (maximum [pappyErr11,pappyErr9,pappyErr7])
                    Parsed _ _ pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
                pappyAlt7_2 pappyErr7 =
                  case morphologyPlusRule6 d of
                    Parsed ss pappyDvs9 pappyErr9 ->
                      Parsed (
                        concat ss) pappyDvs9 (max pappyErr9 pappyErr7)
                    NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
                pappyAlt7_3 pappyErr7 =
                  case morphologydigit d of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed pappyVal9 pappyDvs9 (max pappyErr9 pappyErr7)
                    NoParse pappyErr9 -> pappyAlt7_4 (max pappyErr9 pappyErr7)
                pappyAlt7_4 pappyErr7 = NoParse pappyErr7
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyCVC_rafsi d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologyy pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      case pappyResult11 of
                        Parsed ms pappyDvs11 pappyErr11 ->
                          case morphologyStarRule4 pappyDvs11 of
                            Parsed ss pappyDvs13 pappyErr13 ->
                              case morphologybrivla_core pappyDvs13 of
                                Parsed s3 pappyDvs15 pappyErr15 ->
                                  Parsed (
                                    s1++s2++fromMaybe "" ms++concat ss++s3) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                                NoParse pappyErr15 -> pappyAlt5_2 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                            NoParse pappyErr13 -> pappyAlt5_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                        NoParse pappyErr11 -> pappyAlt5_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                      where
                        pappyResult11 =
                          case morphologyh pappyDvs9 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
                            NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
                    NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologystressed_CVC_rafsi d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologyy pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      case morphologyshort_final_rafsi pappyDvs9 of
                        Parsed s3 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                        NoParse pappyErr11 -> pappyAlt5_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyParseStarRule3 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule3 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule3 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologynucleus d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyh pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
            NoParse pappyErr5 -> NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseStarRule4 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule4 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule4 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyextended_rafsi d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyy_rafsi d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 =
              case morphologyany_extended_rafsi d of
                NoParse pappyErr7 ->
                  case morphologyy_less_rafsi d of
                    Parsed s pappyDvs9 pappyErr9 ->
                      Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_4 (maximum [pappyErr9,pappyErr7,pappyErr5])
                Parsed _ _ pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
            pappyAlt5_4 pappyErr5 = NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologybrivla_core :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologybrivla_core d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyfuhivla d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologygismu d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyCVV_final_rafsi d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 =
      case pappyResult3 of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologyshort_final_rafsi pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologystressed_extended_rafsi d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologystressed_y_rafsi d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 =
              case morphologystressed_y_less_rafsi d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
            pappyAlt5_4 pappyErr5 = NoParse pappyErr5
    pappyAlt1_5 pappyErr1 = NoParse pappyErr1

morphologyany_extended_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyany_extended_rafsi d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyfuhivla d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyextended_rafsi d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologystressed_extended_rafsi d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologyfuhivla :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyfuhivla d =
  case morphologyfuhivla_head d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologystressed_syllable pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case morphologyStarRule6 pappyDvs3 of
            Parsed ss pappyDvs5 pappyErr5 ->
              case morphologyfinal_syllable pappyDvs5 of
                Parsed s3 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2++concat ss++s3) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsestressed_extended_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsestressed_extended_rafsi d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyunstressed_syllable d of
        Parsed _ _ pappyErr3 ->
          case morphologybrivla_head d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologystressed_syllable pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyh pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      case morphologyy pappyDvs9 of
                        Parsed s4 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3++s4) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyfuhivla_head d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologystressed_syllable pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case morphologyconsonant pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  case morphologyonset pappyDvs5 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      case morphologyy pappyDvs9 of
                        Parsed s4 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3++s4) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        NoParse pappyErr11 -> pappyAlt1_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseextended_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseextended_rafsi d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed _ _ pappyErr3 ->
          case morphologybrivla_head d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyh pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyy pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      case pappyResult11 of
                        Parsed ms pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3++fromMaybe "" ms) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                      where
                        pappyResult11 =
                          case morphologyh pappyDvs9 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
                            NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
                    NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologysyllable d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyStarRule6 pappyDvs5 of
                Parsed ss pappyDvs7 pappyErr7 ->
                  case morphologysyllable pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++concat ss++s2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
            NoParse pappyErr5 -> NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      case morphologyunstressed_syllable d of
        Parsed _ _ pappyErr3 ->
          case morphologyfuhivla_head d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyconsonant pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  case morphologyonset pappyDvs5 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      case morphologyy pappyDvs9 of
                        Parsed s3 pappyDvs11 pappyErr11 ->
                          case pappyResult13 of
                            Parsed ms pappyDvs13 pappyErr13 ->
                              Parsed (
                                s1++s2++s3++fromMaybe "" ms) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                            NoParse pappyErr13 -> pappyAlt1_3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                          where
                            pappyResult13 =
                              case morphologyh pappyDvs11 of
                                Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
                                NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
                        NoParse pappyErr11 -> pappyAlt1_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseStarRule6 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule6 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyconsonantal_syllable d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule6 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyfuhivla_head :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyfuhivla_head d =
  case morphologyrafsi_string d of
    NoParse pappyErr1 ->
      case morphologybrivla_head d of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyParseStarRule7 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule7 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyunstressed_syllable d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule7 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsebrivla_head :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsebrivla_head d =
  case morphologycmavo d of
    NoParse pappyErr1 ->
      case pappyResult3 of
        NoParse pappyErr3 ->
          case morphologyh d of
            NoParse pappyErr5 ->
              case morphologyonset d of
                Parsed _ _ pappyErr7 ->
                  case morphologyStarRule7 d of
                    Parsed ss pappyDvs9 pappyErr9 ->
                      Parsed (
                        concat ss) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyconsonant d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyrafsi_string pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
            NoParse pappyErr5 -> NoParse pappyErr5
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyParseStarRule8 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule8 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyy_less_rafsi d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule8 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyrafsi_string :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyrafsi_string d =
  case morphologyStarRule8 d of
    Parsed ss pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s1 pappyDvs3 pappyErr3 ->
          Parsed (
            concat ss++s1) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos pappyDvs1) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologygismu pappyDvs1 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyCVV_final_rafsi pappyDvs1 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 =
              case morphologystressed_y_less_rafsi pappyDvs1 of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologyshort_final_rafsi pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_4 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
            pappyAlt5_4 pappyErr5 =
              case morphologyy_rafsi pappyDvs1 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_5 (max pappyErr7 pappyErr5)
            pappyAlt5_5 pappyErr5 =
              case morphologystressed_y_rafsi pappyDvs1 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_6 (max pappyErr7 pappyErr5)
            pappyAlt5_6 pappyErr5 =
              case pappyResult7 of
                Parsed ms pappyDvs7 pappyErr7 ->
                  case morphologyinitial_pair pappyDvs7 of
                    Parsed s1 pappyDvs9 pappyErr9 ->
                      case morphologyy pappyDvs9 of
                        Parsed s2 pappyDvs11 pappyErr11 ->
                          Parsed (
                            fromMaybe "" ms++s1++s2) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                        NoParse pappyErr11 -> pappyAlt5_7 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_7 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_7 (max pappyErr7 pappyErr5)
              where
                pappyResult7 =
                  case morphologystressed_y_less_rafsi pappyDvs1 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs1 pappyErr9
            pappyAlt5_7 pappyErr5 = NoParse pappyErr5
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsegismu :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsegismu d =
  case pappyResult1 of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyfinal_syllable pappyDvs1 of
        Parsed _ _ pappyErr3 ->
          case morphologyconsonant pappyDvs1 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case morphologyvowel pappyDvs5 of
                Parsed s3 pappyDvs7 pappyErr7 ->
                  case morphologypost_word pappyDvs7 of
                    Parsed _ _ pappyErr9 ->
                      Parsed (
                        s1++s2++s3) pappyDvs7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologyinitial_pair d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologystressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologyconsonant d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologystressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyconsonant pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2++s3) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 = NoParse pappyErr3

morphologyParseCVV_final_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseCVV_final_rafsi d =
  case morphologyconsonant d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologystressed_vowel pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            Parsed s3 pappyDvs5 pappyErr5 ->
              case morphologyfinal_syllable pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  case morphologyvowel pappyDvs5 of
                    Parsed s4 pappyDvs9 pappyErr9 ->
                      case morphologypost_word pappyDvs9 of
                        Parsed _ _ pappyErr11 ->
                          Parsed (
                            s1++s2++s3++s4) pappyDvs9 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseshort_final_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseshort_final_rafsi d =
  case morphologyfinal_syllable d of
    Parsed _ _ pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologypost_word pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyconsonant d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologydiphthong pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyinitial_pair d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologyvowel pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsestressed_y_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsestressed_y_rafsi d =
  case pappyResult1 of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyy pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          Parsed (
            s1++s2) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologyinitial_pair d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologystressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyconsonant pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2++s3) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologyconsonant d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologystressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyconsonant pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      case morphologyconsonant pappyDvs9 of
                        Parsed s4 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3++s4) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                        NoParse pappyErr11 -> pappyAlt3_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 =
          case morphologystressed_CVC_rafsi d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
        pappyAlt3_4 pappyErr3 = NoParse pappyErr3

morphologyParsestressed_y_less_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsestressed_y_less_rafsi d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologystressed_CVC_rafsi d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyy pappyDvs3 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyinitial_pair d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologystressed_vowel pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyconsonant d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case pappyResult7 of
                Parsed ms pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2++fromMaybe "" ms) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
              where
                pappyResult7 =
                  case morphologyr_hyphen pappyDvs5 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
            NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (morphologyPos pappyDvs3) []) where
                pappyAlt7_1 pappyErr7 =
                  case morphologyunstressed_vowel pappyDvs3 of
                    Parsed s1 pappyDvs9 pappyErr9 ->
                      case morphologyh pappyDvs9 of
                        Parsed s2 pappyDvs11 pappyErr11 ->
                          case morphologystressed_vowel pappyDvs11 of
                            Parsed s3 pappyDvs13 pappyErr13 ->
                              Parsed (
                                s1++s2++s3) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                            NoParse pappyErr13 -> pappyAlt7_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
                        NoParse pappyErr11 -> pappyAlt7_2 (maximum [pappyErr11,pappyErr9,pappyErr7])
                    NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
                pappyAlt7_2 pappyErr7 =
                  pappyAlt9_1 pappyErr7 where
                    pappyAlt9_1 pappyErr9 =
                      case morphologystressed pappyDvs3 of
                        Parsed _ _ pappyErr11 ->
                          case morphologydiphthong pappyDvs3 of
                            Parsed s pappyDvs13 pappyErr13 ->
                              Parsed (s) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9])
                            NoParse pappyErr13 -> pappyAlt9_2 (maximum [pappyErr13,pappyErr11,pappyErr9])
                        NoParse pappyErr11 -> pappyAlt9_2 (max pappyErr11 pappyErr9)
                    pappyAlt9_2 pappyErr9 =
                      case morphologydiphthong pappyDvs3 of
                        Parsed s pappyDvs11 pappyErr11 ->
                          case morphologystress pappyDvs11 of
                            Parsed _ _ pappyErr13 ->
                              Parsed (s) pappyDvs11 (maximum [pappyErr13,pappyErr11,pappyErr9])
                            NoParse pappyErr13 -> pappyAlt9_3 (maximum [pappyErr13,pappyErr11,pappyErr9])
                        NoParse pappyErr11 -> pappyAlt9_3 (max pappyErr11 pappyErr9)
                    pappyAlt9_3 pappyErr9 = pappyAlt7_3 pappyErr9
                pappyAlt7_3 pappyErr7 = NoParse pappyErr7
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologystressed_CVC_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologystressed_CVC_rafsi d =
  case morphologyconsonant d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologystressed_vowel pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case morphologyconsonant pappyDvs3 of
            Parsed s3 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2++s3) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsey_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsey_rafsi d =
  case pappyResult1 of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyy pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed ms pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2++fromMaybe "" ms) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              case morphologyh pappyDvs3 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
                NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologyinitial_pair d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyunstressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyconsonant pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2++s3) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologyconsonant d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyunstressed_vowel pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologyconsonant pappyDvs7 of
                    Parsed s3 pappyDvs9 pappyErr9 ->
                      case morphologyconsonant pappyDvs9 of
                        Parsed s4 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++s3++s4) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                        NoParse pappyErr11 -> pappyAlt3_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 =
          case morphologyCVC_rafsi d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
        pappyAlt3_4 pappyErr3 = NoParse pappyErr3

morphologyParsey_less_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsey_less_rafsi d =
  case morphologyy_rafsi d of
    NoParse pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyany_extended_rafsi pappyDvs3 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyCVC_rafsi d of
                Parsed s pappyDvs7 pappyErr7 ->
                  case morphologyy pappyDvs7 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs7 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    Parsed _ _ pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyinitial_pair d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case morphologyunstressed_vowel pappyDvs7 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      Parsed (
                        s1++s2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 =
              case morphologyconsonant d of
                Parsed s1 pappyDvs7 pappyErr7 ->
                  case pappyResult9 of
                    Parsed s2 pappyDvs9 pappyErr9 ->
                      case pappyResult11 of
                        Parsed ms pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2++fromMaybe "" ms) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                        NoParse pappyErr11 -> pappyAlt5_4 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
                      where
                        pappyResult11 =
                          case morphologyr_hyphen pappyDvs9 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
                            NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
                    NoParse pappyErr9 -> pappyAlt5_4 (maximum [pappyErr9,pappyErr7,pappyErr5])
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (morphologyPos pappyDvs7) []) where
                        pappyAlt11_1 pappyErr11 =
                          case morphologyunstressed_vowel pappyDvs7 of
                            Parsed s1 pappyDvs13 pappyErr13 ->
                              case morphologyh pappyDvs13 of
                                Parsed s2 pappyDvs15 pappyErr15 ->
                                  case morphologyunstressed_vowel pappyDvs15 of
                                    Parsed s3 pappyDvs17 pappyErr17 ->
                                      Parsed (
                                        s1++s2++s3) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11])
                                    NoParse pappyErr17 -> pappyAlt11_2 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11])
                                NoParse pappyErr15 -> pappyAlt11_2 (maximum [pappyErr15,pappyErr13,pappyErr11])
                            NoParse pappyErr13 -> pappyAlt11_2 (max pappyErr13 pappyErr11)
                        pappyAlt11_2 pappyErr11 =
                          case morphologystressed pappyDvs7 of
                            NoParse pappyErr13 ->
                              case morphologydiphthong pappyDvs7 of
                                Parsed s pappyDvs15 pappyErr15 ->
                                  case morphologystress pappyDvs15 of
                                    NoParse pappyErr17 ->
                                      Parsed (s) pappyDvs15 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11])
                                    Parsed _ _ pappyErr17 -> pappyAlt11_3 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11])
                                NoParse pappyErr15 -> pappyAlt11_3 (maximum [pappyErr15,pappyErr13,pappyErr11])
                            Parsed _ _ pappyErr13 -> pappyAlt11_3 (max pappyErr13 pappyErr11)
                        pappyAlt11_3 pappyErr11 = NoParse pappyErr11
                NoParse pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
            pappyAlt5_4 pappyErr5 = NoParse pappyErr5
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyCVC_rafsi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyCVC_rafsi d =
  case morphologyconsonant d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyunstressed_vowel pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case morphologyconsonant pappyDvs3 of
            Parsed s3 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2++s3) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParser_hyphen :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParser_hyphen d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyr d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyconsonant pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyn d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyr pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsefinal_syllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsefinal_syllable d =
  case morphologyonset d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyy pappyDvs1 of
        NoParse pappyErr3 ->
          case morphologystressed pappyDvs1 of
            NoParse pappyErr5 ->
              case morphologynucleus pappyDvs1 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologycmene pappyDvs7 of
                    NoParse pappyErr9 ->
                      case morphologypost_word pappyDvs7 of
                        Parsed _ _ pappyErr11 ->
                          Parsed (
                            s1++s2) pappyDvs7 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsestressed_syllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsestressed_syllable d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologystressed d of
        Parsed _ _ pappyErr3 ->
          case morphologysyllable d of
            Parsed s pappyDvs5 pappyErr5 ->
              Parsed (s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologysyllable d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologystress pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsestressed_vowel :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsestressed_vowel d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologystressed d of
        Parsed _ _ pappyErr3 ->
          case morphologyvowel d of
            Parsed s pappyDvs5 pappyErr5 ->
              Parsed (s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyvowel d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologystress pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseunstressed_syllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseunstressed_syllable d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologystressed d of
        NoParse pappyErr3 ->
          case morphologysyllable d of
            Parsed s pappyDvs5 pappyErr5 ->
              case morphologystress pappyDvs5 of
                NoParse pappyErr7 ->
                  Parsed (s) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyconsonantal_syllable d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyunstressed_vowel :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyunstressed_vowel d =
  case morphologystressed d of
    NoParse pappyErr1 ->
      case morphologyvowel d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologystress pappyDvs3 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyParseStarRule9 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule9 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyconsonant d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule9 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologystress :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologystress d =
  case morphologyStarRule9 d of
    Parsed ss pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed ms pappyDvs3 pappyErr3 ->
          case morphologysyllable pappyDvs3 of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologypause pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    concat ss++fromMaybe "" ms++s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyy pappyDvs1 of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
            NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
    NoParse pappyErr1 -> NoParse pappyErr1

morphologystressed :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologystressed d =
  case morphologyonset d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyStarRule37 pappyDvs1 of
        Parsed ss pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++concat ss++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              case morphologyChar pappyDvs3 of
                Parsed 'A' pappyDvs7 _ ->
                  Parsed (
                    "A") pappyDvs7 (ParseError (morphologyPos pappyDvs7) [])
                Parsed 'E' pappyDvs7 _ ->
                  Parsed (
                    "E") pappyDvs7 (ParseError (morphologyPos pappyDvs7) [])
                Parsed 'I' pappyDvs7 _ ->
                  Parsed (
                    "I") pappyDvs7 (ParseError (morphologyPos pappyDvs7) [])
                Parsed 'O' pappyDvs7 _ ->
                  Parsed (
                    "O") pappyDvs7 (ParseError (morphologyPos pappyDvs7) [])
                Parsed 'U' pappyDvs7 _ ->
                  Parsed (
                    "U") pappyDvs7 (ParseError (morphologyPos pappyDvs7) [])
                _ -> NoParse (ParseError (morphologyPos pappyDvs3) [])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyany_syllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyany_syllable d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyonset d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologynucleus pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case pappyResult7 of
                Parsed ms pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2++fromMaybe "" ms) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
              where
                pappyResult7 =
                  case morphologycoda pappyDvs5 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyconsonantal_syllable d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologysyllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologysyllable d =
  case morphologyonset d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyy pappyDvs1 of
        NoParse pappyErr3 ->
          case morphologynucleus pappyDvs1 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case pappyResult7 of
                Parsed ms pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2++fromMaybe "" ms) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
              where
                pappyResult7 =
                  case morphologycoda pappyDvs5 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseconsonantal_syllable :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseconsonantal_syllable d =
  case morphologyconsonant d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologysyllabic pappyDvs1 of
        Parsed s2 pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed _ _ pappyErr5 ->
              case pappyResult7 of
                Parsed ms pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2++fromMaybe "" ms) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
                  where
                    pappyResult9 =
                      case morphologyconsonant pappyDvs3 of
                        Parsed s pappyDvs11 pappyErr11 ->
                          case pappyResult13 of
                            Parsed _ _ pappyErr13 ->
                              Parsed (s) pappyDvs11 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
                          where
                            pappyResult13 =
                              case morphologyY pappyDvs11 of
                                NoParse pappyErr15 ->
                                  case pappyResult17 of
                                    Parsed s pappyDvs17 pappyErr17 ->
                                      Parsed (s) pappyDvs17 (max pappyErr17 pappyErr15)
                                    NoParse pappyErr17 -> NoParse (max pappyErr17 pappyErr15)
                                  where
                                    pappyResult17 =
                                      pappyAlt19_1 (ParseError (morphologyPos pappyDvs11) []) where
                                        pappyAlt19_1 pappyErr19 =
                                          case morphologyPlusRule5 pappyDvs11 of
                                            Parsed ss pappyDvs21 pappyErr21 ->
                                              case pappyResult23 of
                                                Parsed ms pappyDvs23 pappyErr23 ->
                                                  Parsed (
                                                    concat ss++fromMaybe "" ms) pappyDvs23 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                                NoParse pappyErr23 -> pappyAlt19_2 (maximum [pappyErr23,pappyErr21,pappyErr19])
                                              where
                                                pappyResult23 =
                                                  case morphologyspace_char pappyDvs21 of
                                                    Parsed pappyVal25 pappyDvs25 pappyErr25 -> Parsed (Just pappyVal25) pappyDvs25 pappyErr25
                                                    NoParse pappyErr25 -> Parsed (Nothing) pappyDvs21 pappyErr25
                                            NoParse pappyErr21 -> pappyAlt19_2 (max pappyErr21 pappyErr19)
                                        pappyAlt19_2 pappyErr19 =
                                          case morphologyspace_char pappyDvs11 of
                                            Parsed pappyVal21 pappyDvs21 pappyErr21 -> Parsed pappyVal21 pappyDvs21 (max pappyErr21 pappyErr19)
                                            NoParse pappyErr21 -> pappyAlt19_3 (max pappyErr21 pappyErr19)
                                        pappyAlt19_3 pappyErr19 = NoParse pappyErr19
                                Parsed _ _ pappyErr15 -> NoParse pappyErr15
                        NoParse pappyErr11 -> NoParse pappyErr11
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              pappyAlt7_1 (ParseError (morphologyPos pappyDvs3) []) where
                pappyAlt7_1 pappyErr7 =
                  case morphologyconsonantal_syllable pappyDvs3 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed pappyVal9 pappyDvs9 (max pappyErr9 pappyErr7)
                    NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
                pappyAlt7_2 pappyErr7 =
                  case morphologyonset pappyDvs3 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed pappyVal9 pappyDvs9 (max pappyErr9 pappyErr7)
                    NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
                pappyAlt7_3 pappyErr7 = NoParse pappyErr7
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsecoda :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsecoda d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyany_syllable d of
        NoParse pappyErr3 ->
          case morphologyconsonant d of
            Parsed s pappyDvs5 pappyErr5 ->
              case morphologyany_syllable pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  Parsed (s) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case pappyResult3 of
        Parsed ms1 pappyDvs3 pappyErr3 ->
          case pappyResult5 of
            Parsed ms2 pappyDvs5 pappyErr5 ->
              case morphologypause pappyDvs5 of
                Parsed _ _ pappyErr7 ->
                  Parsed (
                    fromMaybe "" ms1++fromMaybe "" ms2) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
          where
            pappyResult5 =
              case morphologyconsonant pappyDvs3 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
                NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologysyllabic d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
            NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseonset :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseonset d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyh d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case pappyResult3 of
        Parsed ms pappyDvs3 pappyErr3 ->
          case morphologyglide pappyDvs3 of
            Parsed s pappyDvs5 pappyErr5 ->
              Parsed (
                fromMaybe "" ms++s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyconsonant d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
            NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
    pappyAlt1_3 pappyErr1 =
      case morphologyinitial d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologyParsenucleus :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsenucleus d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyvowel d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologydiphthong d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyy d of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologynucleus pappyDvs3 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologyParseglide :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseglide d =
  case pappyResult1 of
    Parsed s pappyDvs1 pappyErr1 ->
      case morphologynucleus pappyDvs1 of
        Parsed _ _ pappyErr3 ->
          case morphologyglide pappyDvs1 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs1 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologyi d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologyu d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 = NoParse pappyErr3

morphologyParsediphthong :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsediphthong d =
  case pappyResult1 of
    Parsed s pappyDvs1 pappyErr1 ->
      case morphologynucleus pappyDvs1 of
        NoParse pappyErr3 ->
          case morphologyglide pappyDvs1 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs1 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologya d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyi pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologya d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyu pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 =
          case morphologye d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyi pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_4 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
        pappyAlt3_4 pappyErr3 =
          case morphologyo d of
            Parsed s1 pappyDvs5 pappyErr5 ->
              case morphologyi pappyDvs5 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
                NoParse pappyErr7 -> pappyAlt3_5 (maximum [pappyErr7,pappyErr5,pappyErr3])
            NoParse pappyErr5 -> pappyAlt3_5 (max pappyErr5 pappyErr3)
        pappyAlt3_5 pappyErr3 = NoParse pappyErr3

morphologyParsevowel :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsevowel d =
  case pappyResult1 of
    Parsed s pappyDvs1 pappyErr1 ->
      case morphologynucleus pappyDvs1 of
        NoParse pappyErr3 ->
          Parsed (s) pappyDvs1 (max pappyErr3 pappyErr1)
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologya d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case morphologye d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
        pappyAlt3_3 pappyErr3 =
          case morphologyi d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
        pappyAlt3_4 pappyErr3 =
          case morphologyo d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_5 (max pappyErr5 pappyErr3)
        pappyAlt3_5 pappyErr3 =
          case morphologyu d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_6 (max pappyErr5 pappyErr3)
        pappyAlt3_6 pappyErr3 = NoParse pappyErr3

morphologya :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologya d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'a' pappyDvs5 _ ->
              Parsed (
                "a") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'A' pappyDvs5 _ ->
              Parsed (
                "A") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologye :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologye d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'e' pappyDvs5 _ ->
              Parsed (
                "e") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'E' pappyDvs5 _ ->
              Parsed (
                "E") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyi :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyi d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'i' pappyDvs5 _ ->
              Parsed (
                "i") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'I' pappyDvs5 _ ->
              Parsed (
                "I") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyo :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyo d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'o' pappyDvs5 _ ->
              Parsed (
                "o") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'O' pappyDvs5 _ ->
              Parsed (
                "O") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyu :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyu d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'u' pappyDvs5 _ ->
              Parsed (
                "u") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'U' pappyDvs5 _ ->
              Parsed (
                "U") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyy :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyy d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'y' pappyDvs5 _ ->
              Parsed (
                "y") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'Y' pappyDvs5 _ ->
              Parsed (
                "Y") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsePlusRule2 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule2 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyconsonant d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule2 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyconsonant d of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologycluster :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologycluster d =
  case morphologyconsonant d of
    Parsed s pappyDvs1 pappyErr1 ->
      case morphologyPlusRule2 pappyDvs1 of
        Parsed ss pappyDvs3 pappyErr3 ->
          Parsed (
            s++concat ss) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseinitial_pair :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseinitial_pair d =
  case morphologyinitial d of
    Parsed _ _ pappyErr1 ->
      case morphologyconsonant d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologyconsonant pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              case morphologyconsonant pappyDvs5 of
                NoParse pappyErr7 ->
                  Parsed (
                    s1++s2) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseinitial :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseinitial d =
  case pappyResult1 of
    Parsed s pappyDvs1 pappyErr1 ->
      case morphologyconsonant pappyDvs1 of
        NoParse pappyErr3 ->
          case morphologyglide pappyDvs1 of
            NoParse pappyErr5 ->
              Parsed (s) pappyDvs1 (maximum [pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1
  where
    pappyResult1 =
      pappyAlt3_1 (ParseError (morphologyPos d) []) where
        pappyAlt3_1 pappyErr3 =
          case morphologyaffricate d of
            Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed pappyVal5 pappyDvs5 (max pappyErr5 pappyErr3)
            NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
        pappyAlt3_2 pappyErr3 =
          case pappyResult5 of
            Parsed ms1 pappyDvs5 pappyErr5 ->
              case pappyResult7 of
                Parsed ms2 pappyDvs7 pappyErr7 ->
                  case pappyResult9 of
                    Parsed ms3 pappyDvs9 pappyErr9 ->
                      Parsed (
                        fromMaybe "" ms1++fromMaybe "" ms2++fromMaybe "" ms3) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                    NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
                  where
                    pappyResult9 =
                      case morphologyliquid pappyDvs7 of
                        Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
                        NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
                NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
              where
                pappyResult7 =
                  case pappyResult9 of
                    Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
                    NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
                  where
                    pappyResult9 =
                      pappyAlt11_1 (ParseError (morphologyPos pappyDvs5) []) where
                        pappyAlt11_1 pappyErr11 =
                          case morphologyp pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_2 (max pappyErr13 pappyErr11)
                        pappyAlt11_2 pappyErr11 =
                          case morphologyt pappyDvs5 of
                            Parsed s pappyDvs13 pappyErr13 ->
                              case morphologyl pappyDvs13 of
                                NoParse pappyErr15 ->
                                  Parsed (s) pappyDvs13 (maximum [pappyErr15,pappyErr13,pappyErr11])
                                Parsed _ _ pappyErr15 -> pappyAlt11_3 (maximum [pappyErr15,pappyErr13,pappyErr11])
                            NoParse pappyErr13 -> pappyAlt11_3 (max pappyErr13 pappyErr11)
                        pappyAlt11_3 pappyErr11 =
                          case morphologyk pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_4 (max pappyErr13 pappyErr11)
                        pappyAlt11_4 pappyErr11 =
                          case morphologyf pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_5 (max pappyErr13 pappyErr11)
                        pappyAlt11_5 pappyErr11 =
                          case morphologyx pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_6 (max pappyErr13 pappyErr11)
                        pappyAlt11_6 pappyErr11 =
                          case morphologyb pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_7 (max pappyErr13 pappyErr11)
                        pappyAlt11_7 pappyErr11 =
                          case morphologyd pappyDvs5 of
                            Parsed s pappyDvs13 pappyErr13 ->
                              case morphologyl pappyDvs13 of
                                NoParse pappyErr15 ->
                                  Parsed (s) pappyDvs13 (maximum [pappyErr15,pappyErr13,pappyErr11])
                                Parsed _ _ pappyErr15 -> pappyAlt11_8 (maximum [pappyErr15,pappyErr13,pappyErr11])
                            NoParse pappyErr13 -> pappyAlt11_8 (max pappyErr13 pappyErr11)
                        pappyAlt11_8 pappyErr11 =
                          case morphologyg pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_9 (max pappyErr13 pappyErr11)
                        pappyAlt11_9 pappyErr11 =
                          case morphologyv pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_10 (max pappyErr13 pappyErr11)
                        pappyAlt11_10 pappyErr11 =
                          case morphologym pappyDvs5 of
                            Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed pappyVal13 pappyDvs13 (max pappyErr13 pappyErr11)
                            NoParse pappyErr13 -> pappyAlt11_11 (max pappyErr13 pappyErr11)
                        pappyAlt11_11 pappyErr11 =
                          case morphologyn pappyDvs5 of
                            Parsed s pappyDvs13 pappyErr13 ->
                              case morphologyliquid pappyDvs13 of
                                NoParse pappyErr15 ->
                                  Parsed (s) pappyDvs13 (maximum [pappyErr15,pappyErr13,pappyErr11])
                                Parsed _ _ pappyErr15 -> pappyAlt11_12 (maximum [pappyErr15,pappyErr13,pappyErr11])
                            NoParse pappyErr13 -> pappyAlt11_12 (max pappyErr13 pappyErr11)
                        pappyAlt11_12 pappyErr11 = NoParse pappyErr11
            NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
          where
            pappyResult5 =
              case pappyResult7 of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
                NoParse pappyErr7 -> Parsed (Nothing) d pappyErr7
              where
                pappyResult7 =
                  pappyAlt9_1 (ParseError (morphologyPos d) []) where
                    pappyAlt9_1 pappyErr9 =
                      case morphologyc d of
                        Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed pappyVal11 pappyDvs11 (max pappyErr11 pappyErr9)
                        NoParse pappyErr11 -> pappyAlt9_2 (max pappyErr11 pappyErr9)
                    pappyAlt9_2 pappyErr9 =
                      case morphologys d of
                        Parsed s pappyDvs11 pappyErr11 ->
                          case morphologyx pappyDvs11 of
                            NoParse pappyErr13 ->
                              Parsed (s) pappyDvs11 (maximum [pappyErr13,pappyErr11,pappyErr9])
                            Parsed _ _ pappyErr13 -> pappyAlt9_3 (maximum [pappyErr13,pappyErr11,pappyErr9])
                        NoParse pappyErr11 -> pappyAlt9_3 (max pappyErr11 pappyErr9)
                    pappyAlt9_3 pappyErr9 =
                      case pappyResult11 of
                        Parsed s pappyDvs11 pappyErr11 ->
                          case morphologyn pappyDvs11 of
                            NoParse pappyErr13 ->
                              case morphologyliquid pappyDvs11 of
                                NoParse pappyErr15 ->
                                  Parsed (s) pappyDvs11 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9])
                                Parsed _ _ pappyErr15 -> pappyAlt9_4 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9])
                            Parsed _ _ pappyErr13 -> pappyAlt9_4 (maximum [pappyErr13,pappyErr11,pappyErr9])
                        NoParse pappyErr11 -> pappyAlt9_4 (max pappyErr11 pappyErr9)
                      where
                        pappyResult11 =
                          pappyAlt13_1 (ParseError (morphologyPos d) []) where
                            pappyAlt13_1 pappyErr13 =
                              case morphologyj d of
                                Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed pappyVal15 pappyDvs15 (max pappyErr15 pappyErr13)
                                NoParse pappyErr15 -> pappyAlt13_2 (max pappyErr15 pappyErr13)
                            pappyAlt13_2 pappyErr13 =
                              case morphologyz d of
                                Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed pappyVal15 pappyDvs15 (max pappyErr15 pappyErr13)
                                NoParse pappyErr15 -> pappyAlt13_3 (max pappyErr15 pappyErr13)
                            pappyAlt13_3 pappyErr13 = NoParse pappyErr13
                    pappyAlt9_4 pappyErr9 = NoParse pappyErr9
        pappyAlt3_3 pappyErr3 = NoParse pappyErr3

morphologyaffricate :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyaffricate d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyt d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologyc pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyt d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologys pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyd d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologyj pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 =
      case morphologyd d of
        Parsed s1 pappyDvs3 pappyErr3 ->
          case morphologyz pappyDvs3 of
            Parsed s2 pappyDvs5 pappyErr5 ->
              Parsed (
                s1++s2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
    pappyAlt1_5 pappyErr1 = NoParse pappyErr1

morphologyliquid :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyliquid d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyl d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyr d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyconsonant :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyconsonant d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyvoiced d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyunvoiced d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologysyllabic d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 = NoParse pappyErr1

morphologysyllabic :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologysyllabic d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyl d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologym d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyn d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 =
      case morphologyr d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
    pappyAlt1_5 pappyErr1 = NoParse pappyErr1

morphologyvoiced :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyvoiced d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyb d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyd d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyg d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 =
      case morphologyj d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
    pappyAlt1_5 pappyErr1 =
      case morphologyv d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
    pappyAlt1_6 pappyErr1 =
      case morphologyz d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
    pappyAlt1_7 pappyErr1 = NoParse pappyErr1

morphologyunvoiced :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyunvoiced d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyc d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyf d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 =
      case morphologyk d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
    pappyAlt1_4 pappyErr1 =
      case morphologyp d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
    pappyAlt1_5 pappyErr1 =
      case morphologys d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
    pappyAlt1_6 pappyErr1 =
      case morphologyt d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
    pappyAlt1_7 pappyErr1 =
      case morphologyx d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
    pappyAlt1_8 pappyErr1 = NoParse pappyErr1

morphologyParsel :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsel d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyl pappyDvs3 of
                NoParse pappyErr7 ->
                  Parsed (s) pappyDvs3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'l' pappyDvs5 _ ->
              Parsed (
                "l") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'L' pappyDvs5 _ ->
              Parsed (
                "L") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsem :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsem d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologym pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyz pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'm' pappyDvs5 _ ->
              Parsed (
                "m") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'M' pappyDvs5 _ ->
              Parsed (
                "M") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsen :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsen d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyn pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyaffricate pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'n' pappyDvs5 _ ->
              Parsed (
                "n") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'N' pappyDvs5 _ ->
              Parsed (
                "N") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParser :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParser d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyr pappyDvs3 of
                NoParse pappyErr7 ->
                  Parsed (s) pappyDvs3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'r' pappyDvs5 _ ->
              Parsed (
                "r") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'R' pappyDvs5 _ ->
              Parsed (
                "R") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseb :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseb d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyb pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyunvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'b' pappyDvs5 _ ->
              Parsed (
                "b") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'B' pappyDvs5 _ ->
              Parsed (
                "B") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsed :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsed d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyd pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyunvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'd' pappyDvs5 _ ->
              Parsed (
                "d") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'D' pappyDvs5 _ ->
              Parsed (
                "D") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseg :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseg d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyg pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyunvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'g' pappyDvs5 _ ->
              Parsed (
                "g") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'G' pappyDvs5 _ ->
              Parsed (
                "G") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsev :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsev d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyv pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyunvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'v' pappyDvs5 _ ->
              Parsed (
                "v") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'V' pappyDvs5 _ ->
              Parsed (
                "V") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsej :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsej d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyj pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyz pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyunvoiced pappyDvs3 of
                        NoParse pappyErr11 ->
                          Parsed (s) pappyDvs3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'j' pappyDvs5 _ ->
              Parsed (
                "j") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'J' pappyDvs5 _ ->
              Parsed (
                "J") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsez :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsez d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyz pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyj pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyunvoiced pappyDvs3 of
                        NoParse pappyErr11 ->
                          Parsed (s) pappyDvs3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'z' pappyDvs5 _ ->
              Parsed (
                "z") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'Z' pappyDvs5 _ ->
              Parsed (
                "Z") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParses :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParses d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologys pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyc pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyvoiced pappyDvs3 of
                        NoParse pappyErr11 ->
                          Parsed (s) pappyDvs3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 's' pappyDvs5 _ ->
              Parsed (
                "s") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'S' pappyDvs5 _ ->
              Parsed (
                "S") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsec :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsec d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyc pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologys pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyx pappyDvs3 of
                        NoParse pappyErr11 ->
                          case morphologyvoiced pappyDvs3 of
                            NoParse pappyErr13 ->
                              Parsed (s) pappyDvs3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                            Parsed _ _ pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'c' pappyDvs5 _ ->
              Parsed (
                "c") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'C' pappyDvs5 _ ->
              Parsed (
                "C") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsex :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsex d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyx pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyc pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyk pappyDvs3 of
                        NoParse pappyErr11 ->
                          case morphologyvoiced pappyDvs3 of
                            NoParse pappyErr13 ->
                              Parsed (s) pappyDvs3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                            Parsed _ _ pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'x' pappyDvs5 _ ->
              Parsed (
                "x") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'X' pappyDvs5 _ ->
              Parsed (
                "X") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsek :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsek d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyk pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyx pappyDvs3 of
                    NoParse pappyErr9 ->
                      case morphologyvoiced pappyDvs3 of
                        NoParse pappyErr11 ->
                          Parsed (s) pappyDvs3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                        Parsed _ _ pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'k' pappyDvs5 _ ->
              Parsed (
                "k") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'K' pappyDvs5 _ ->
              Parsed (
                "K") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsef :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsef d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyf pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'f' pappyDvs5 _ ->
              Parsed (
                "f") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'F' pappyDvs5 _ ->
              Parsed (
                "F") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsep :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParsep d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyp pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 'p' pappyDvs5 _ ->
              Parsed (
                "p") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'P' pappyDvs5 _ ->
              Parsed (
                "P") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParset :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParset d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologyt pappyDvs3 of
                NoParse pappyErr7 ->
                  case morphologyvoiced pappyDvs3 of
                    NoParse pappyErr9 ->
                      Parsed (s) pappyDvs3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed 't' pappyDvs5 _ ->
              Parsed (
                "t") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'T' pappyDvs5 _ ->
              Parsed (
                "T") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyh :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyh d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologynucleus pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed '\'' pappyDvs5 _ ->
              Parsed (
                "'") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed 'h' pappyDvs5 _ ->
              Parsed (
                "h") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologydigit :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologydigit d =
  case morphologyStarRule37 d of
    Parsed _ pappyDvs1 pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologyh pappyDvs3 of
            NoParse pappyErr5 ->
              case morphologynucleus pappyDvs3 of
                NoParse pappyErr7 ->
                  Parsed (s) pappyDvs3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                Parsed _ _ pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
            Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar pappyDvs1 of
            Parsed '0' pappyDvs5 _ ->
              Parsed (
                "0") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '1' pappyDvs5 _ ->
              Parsed (
                "1") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '2' pappyDvs5 _ ->
              Parsed (
                "2") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '3' pappyDvs5 _ ->
              Parsed (
                "3") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '4' pappyDvs5 _ ->
              Parsed (
                "4") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '5' pappyDvs5 _ ->
              Parsed (
                "5") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '6' pappyDvs5 _ ->
              Parsed (
                "6") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '7' pappyDvs5 _ ->
              Parsed (
                "7") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '8' pappyDvs5 _ ->
              Parsed (
                "8") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            Parsed '9' pappyDvs5 _ ->
              Parsed (
                "9") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos pappyDvs1) [])
    NoParse pappyErr1 -> NoParse pappyErr1

morphologypost_word :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologypost_word d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologypause d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologynucleus d of
        NoParse pappyErr3 ->
          case morphologylojban_word d of
            Parsed s pappyDvs5 pappyErr5 ->
              Parsed (s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
        Parsed _ _ pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsePlusRule3 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule3 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyspace_char d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule3 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyspace_char d of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologypause :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologypause d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyStarRule37 d of
        Parsed ss1 pappyDvs3 pappyErr3 ->
          case morphologyPlusRule3 pappyDvs3 of
            Parsed ss2 pappyDvs5 pappyErr5 ->
              Parsed (
                concat ss1++concat ss2) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyspace_char d of
        Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParsePlusRule4 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule4 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologynon_space d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule4 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologynon_space d of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologynon_space :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologynon_space d =
  case morphologyspace_char d of
    NoParse pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar d of
            Parsed '.' pappyDvs5 _ ->
              Parsed (
                ".") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos d) [])
    Parsed _ _ pappyErr1 -> NoParse pappyErr1

morphologyspace_char :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyspace_char d =
  case morphologyChar d of
    Parsed c pappyDvs1 pappyErr1 ->
      case (c `elem` ".\t\n\r?! ") of
        True ->
          Parsed (
            [c]) pappyDvs1 pappyErr1
        False -> NoParse pappyErr1
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsePlusRule5 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule5 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule5 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyinitial_spaces_sub d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyybu d of
                NoParse pappyErr7 ->
                  case morphologyY d of
                    Parsed s pappyDvs9 pappyErr9 ->
                      Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                Parsed _ _ pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    pappyAlt1_2 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          pappyAlt5_1 (ParseError (morphologyPos d) []) where
            pappyAlt5_1 pappyErr5 =
              case morphologyinitial_spaces_sub d of
                Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
                NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
            pappyAlt5_2 pappyErr5 =
              case morphologyybu d of
                NoParse pappyErr7 ->
                  case morphologyY d of
                    Parsed s pappyDvs9 pappyErr9 ->
                      Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
                    NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
                Parsed _ _ pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
            pappyAlt5_3 pappyErr5 = NoParse pappyErr5
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseStarRule37 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule37 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case pappyResult3 of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule37 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyChar d of
            Parsed ',' pappyDvs5 _ ->
              Parsed (
                ",") pappyDvs5 (ParseError (morphologyPos pappyDvs5) [])
            _ -> NoParse (ParseError (morphologyPos d) [])
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyinitial_spaces_sub :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyinitial_spaces_sub d =
  case morphologyStarRule37 d of
    Parsed ss pappyDvs1 pappyErr1 ->
      case morphologyspace_char pappyDvs1 of
        Parsed s pappyDvs3 pappyErr3 ->
          Parsed (
            concat ss++s) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParseStarRule38 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParseStarRule38 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyspace_char d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyStarRule38 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      Parsed (
        []) d pappyErr1
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyParseybu :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyParseybu d =
  case morphologyY d of
    Parsed s1 pappyDvs1 pappyErr1 ->
      case morphologyStarRule38 pappyDvs1 of
        Parsed ss pappyDvs3 pappyErr3 ->
          case morphologycmavo pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              case pappyResult7 of
                Parsed s2 pappyDvs7 pappyErr7 ->
                  case morphologypost_word pappyDvs7 of
                    Parsed _ _ pappyErr9 ->
                      Parsed (
                        s1++concat ss++s2) pappyDvs7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                    NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
                NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
              where
                pappyResult7 =
                  case morphologyb pappyDvs3 of
                    Parsed s1 pappyDvs9 pappyErr9 ->
                      case morphologyu pappyDvs9 of
                        Parsed s2 pappyDvs11 pappyErr11 ->
                          Parsed (
                            s1++s2) pappyDvs11 (max pappyErr11 pappyErr9)
                        NoParse pappyErr11 -> NoParse (max pappyErr11 pappyErr9)
                    NoParse pappyErr9 -> NoParse pappyErr9
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
    NoParse pappyErr1 -> NoParse pappyErr1

morphologyParsePlusRule6 :: MorphologyDerivs -> Result MorphologyDerivs ([String])
morphologyParsePlusRule6 d =
  pappyAlt1_1 (ParseError (morphologyPos d) []) where
    pappyAlt1_1 pappyErr1 =
      case morphologyy d of
        Parsed v pappyDvs3 pappyErr3 ->
          case morphologyPlusRule6 pappyDvs3 of
            Parsed vs pappyDvs5 pappyErr5 ->
              Parsed (
                v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
    pappyAlt1_2 pappyErr1 =
      case morphologyy d of
        Parsed v pappyDvs3 pappyErr3 ->
          Parsed (
            [v]) pappyDvs3 (max pappyErr3 pappyErr1)
        NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
    pappyAlt1_3 pappyErr1 = NoParse pappyErr1

morphologyY :: MorphologyDerivs -> Result MorphologyDerivs (String)
morphologyY d =
  case morphologycmavo d of
    Parsed _ _ pappyErr1 ->
      case pappyResult3 of
        Parsed s pappyDvs3 pappyErr3 ->
          case morphologypost_word pappyDvs3 of
            Parsed _ _ pappyErr5 ->
              Parsed (s) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
            NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
        NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
      where
        pappyResult3 =
          case morphologyPlusRule6 d of
            Parsed ss pappyDvs5 pappyErr5 ->
              Parsed (
                concat ss) pappyDvs5 pappyErr5
            NoParse pappyErr5 -> NoParse pappyErr5
    NoParse pappyErr1 -> NoParse pappyErr1