diff --git a/examples/letter/Letter.gfcm b/examples/letter/Letter.gfcm index 6cf296396..9c6579af7 100644 --- a/examples/letter/Letter.gfcm +++ b/examples/letter/Letter.gfcm @@ -1,4 +1,10 @@ -concrete Russian of Letter = open ResRusU in {flags startcat = Letter ;flags lexer = textlit ;flags unlexer = textlit ;flags coding = utf8 ;lincat Author = {s : (ResRusU.Num => (ResRusU.Gen => Str)) ;n : ResRusU.DepNum ;g : ResRusU.DepGen }= {s = table ResRusU.Num {(ResRusU.sg)(ResRusU.pl)=> table ResRusU.Gen {(ResRusU.masc)(ResRusU.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; +concrete Russian of Letter = open ResRusU in { +flags modulesize = n42 ; +flags startcat = Letter ; +flags lexer = textlit ; +flags unlexer = textlit ; +flags coding = utf8 ; +lincat Author = {s : (ResRusU.Num => (ResRusU.Gen => Str)) ;n : ResRusU.DepNum ;g : ResRusU.DepGen }= {s = table ResRusU.Num {(ResRusU.sg)(ResRusU.pl)=> table ResRusU.Gen {(ResRusU.masc)(ResRusU.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; lin BePromoted : Letter.Sentence = \ Position @ 0 -> {s = table ResRusU.DepNum {(ResRusU.depnum)(ResRusU.cnum (ResRusU.sg)) (ResRusU.cnum (ResRusU.pl)) => table ResRusU.DepGen {(ResRusU.depgen)(ResRusU.cgen (ResRusU.masc)) (ResRusU.cgen (ResRusU.fem)) => table ResRusU.Num {(ResRusU.pl)=> table ResRusU.Gen {(ResRusU.fem)=> "вы" ++ "были" ++ ("назначены" ++ Position @ 0.s ! ! ) ;(ResRusU.masc)=> "вы" ++ "были" ++ ("назначены" ++ Position @ 0.s ! ! ) } ;(ResRusU.sg)=> table ResRusU.Gen {(ResRusU.masc)=> "ты" ++ "был" ++ ("назначен" ++ Position @ 0.s ! ! ) ;(ResRusU.fem)=> "ты" ++ "была" ++ ("назначена" ++ Position @ 0.s ! ! ) }}}}} ;"(ты был)назначен Position_0" ; lin ColleagueHe : Letter.Recipient = \ -> {s = "коллега" ;n = ;g = } ;"коллега" ; lin ColleagueShe : Letter.Recipient = \ -> {s = "коллега" ;n = ;g = } ;"коллега" ; @@ -41,13 +47,17 @@ lin Senior : Letter.Position = \ -> {s = table ResRusU.Num {(ResRusU.sg)=> table lincat Sentence = {s : (ResRusU.DepNum => (ResRusU.DepGen => (ResRusU.Num => (ResRusU.Gen => Str)))) }= {s = table ResRusU.DepNum {(ResRusU.depnum)(ResRusU.cnum (ResRusU.sg)) (ResRusU.cnum (ResRusU.pl)) => table ResRusU.DepGen {(ResRusU.depgen)(ResRusU.cgen (ResRusU.masc)) (ResRusU.cgen (ResRusU.fem)) => table ResRusU.Num {(ResRusU.sg)(ResRusU.pl)=> table ResRusU.Gen {(ResRusU.masc)(ResRusU.fem)=> str @ 0 }}}}} ;"Sentence" ; lin Spouse : Letter.Author = \ -> {s = table ResRusU.Num {(ResRusU.sg)=> table ResRusU.Gen {(ResRusU.fem)=> "твой" ++ "муж" ;(ResRusU.masc)=> "твоя" ++ "жена" } ;(ResRusU.pl)=> table ResRusU.Gen {(ResRusU.masc)=> "ваши" ++ "жены" ;(ResRusU.fem)=> "ваши" ++ "мужья" }} ;n = ;g = } ;"твоя жена" ; } -resource ResRusU = {param DepGen = depgen | cgen ResRusU.Gen ; +resource ResRusU = { +flags modulesize = n5 ; +param DepGen = depgen | cgen ResRusU.Gen ; param DepNum = depnum | cnum ResRusU.Num ; param Gen = masc | fem ; param Kas = nom | acc ; param Num = sg | pl ; } -abstract Letter = {cat Author [] = ; +abstract Letter = { +flags modulesize = n42 ; +cat Author [] = ; fun BePromoted : (h_ : Letter.Position)-> Letter.Sentence = {} ; fun ColleagueHe : Letter.Recipient = {} ; fun ColleagueShe : Letter.Recipient = {} ; @@ -90,7 +100,12 @@ fun Senior : Letter.Position = {} ; cat Sentence [] = ; fun Spouse : Letter.Author = {} ; } -concrete Finnish of Letter = open ResFin in {flags startcat = Letter ;flags lexer = textlit ;flags unlexer = textlit ;lincat Author = {s : (ResFin.Num => (ResFin.Gen => Str)) ;n : ResFin.DepNum ;g : ResFin.DepGen }= {s = table ResFin.Num {(ResFin.sg)(ResFin.pl)=> table ResFin.Gen {(ResFin.masc)(ResFin.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; +concrete Finnish of Letter = open ResFin in { +flags modulesize = n42 ; +flags startcat = Letter ; +flags lexer = textlit ; +flags unlexer = textlit ; +lincat Author = {s : (ResFin.Num => (ResFin.Gen => Str)) ;n : ResFin.DepNum ;g : ResFin.DepGen }= {s = table ResFin.Num {(ResFin.sg)(ResFin.pl)=> table ResFin.Gen {(ResFin.masc)(ResFin.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; lin BePromoted : Letter.Sentence = \ Position @ 0 -> {s = table ResFin.DepNum {(ResFin.depnum)(ResFin.cnum (ResFin.sg)) (ResFin.cnum (ResFin.pl)) => table ResFin.DepGen {(ResFin.depgen)(ResFin.cgen (ResFin.masc)) (ResFin.cgen (ResFin.fem)) => table ResFin.Num {(ResFin.sg)=> table ResFin.Gen {(ResFin.fem)=> "sinut" ++ "on" ++ ("ylennetty" ++ Position @ 0.s ! ! ) ;(ResFin.masc)=> "sinut" ++ "on" ++ ("ylennetty" ++ Position @ 0.s ! ! ) } ;(ResFin.pl)=> table ResFin.Gen {(ResFin.fem)=> "teidt" ++ "on" ++ ("ylennetty" ++ Position @ 0.s ! ! ) ;(ResFin.masc)=> "teidt" ++ "on" ++ ("ylennetty" ++ Position @ 0.s ! ! ) }}}}} ;"(sinut on)ylennetty Position_0" ; lin ColleagueHe : Letter.Recipient = \ -> {s = "kollega" ;n = ;g = } ;"kollega" ; lin ColleagueShe : Letter.Recipient = \ -> {s = "kollega" ;n = ;g = } ;"kollega" ; @@ -133,13 +148,20 @@ lin Senior : Letter.Position = \ -> {s = table ResFin.Num {(ResFin.sg)=> table R lincat Sentence = {s : (ResFin.DepNum => (ResFin.DepGen => (ResFin.Num => (ResFin.Gen => Str)))) }= {s = table ResFin.DepNum {(ResFin.depnum)(ResFin.cnum (ResFin.sg)) (ResFin.cnum (ResFin.pl)) => table ResFin.DepGen {(ResFin.depgen)(ResFin.cgen (ResFin.masc)) (ResFin.cgen (ResFin.fem)) => table ResFin.Num {(ResFin.sg)(ResFin.pl)=> table ResFin.Gen {(ResFin.masc)(ResFin.fem)=> str @ 0 }}}}} ;"Sentence" ; lin Spouse : Letter.Author = \ -> {s = table ResFin.Num {(ResFin.pl)=> table ResFin.Gen {(ResFin.fem)=> "miehenne" ;(ResFin.masc)=> "vaimonne" } ;(ResFin.sg)=> table ResFin.Gen {(ResFin.fem)=> "miehesi" ;(ResFin.masc)=> "vaimosi" }} ;n = ;g = } ;"vaimosi" ; } -resource ResFin = {param DepGen = depgen | cgen ResFin.Gen ; +resource ResFin = { +flags modulesize = n5 ; +param DepGen = depgen | cgen ResFin.Gen ; param DepNum = depnum | cnum ResFin.Num ; param Gen = masc | fem ; param Kas = nom | acc ; param Num = sg | pl ; } -concrete Swedish of Letter = open ResSve in {flags startcat = Letter ;flags lexer = textlit ;flags unlexer = textlit ;lincat Author = {s : (ResSve.Num => (ResSve.Sex => Str)) ;n : ResSve.DepNum ;x : ResSve.Sex }= {s = table ResSve.Num {(ResSve.sg)(ResSve.pl)=> table ResSve.Sex {(ResSve.masc)(ResSve.fem)=> str @ 0 }} ;n = ;x = } ;"Author" ; +concrete Swedish of Letter = open ResSve in { +flags modulesize = n42 ; +flags startcat = Letter ; +flags lexer = textlit ; +flags unlexer = textlit ; +lincat Author = {s : (ResSve.Num => (ResSve.Sex => Str)) ;n : ResSve.DepNum ;x : ResSve.Sex }= {s = table ResSve.Num {(ResSve.sg)(ResSve.pl)=> table ResSve.Sex {(ResSve.masc)(ResSve.fem)=> str @ 0 }} ;n = ;x = } ;"Author" ; lin BePromoted : Letter.Sentence = \ Position @ 0 -> {s = table ResSve.DepNum {(ResSve.depnum)(ResSve.cnum (ResSve.sg)) (ResSve.cnum (ResSve.pl)) => table ResSve.Sex {(ResSve.masc)(ResSve.fem)=> table ResSve.Num {(ResSve.sg)=> table ResSve.Sex {(ResSve.fem)=> "du" ++ ("har" ++ "blivit" ++ ("befordrad" ++ ("till" ++ Position @ 0.s ! ! ))) ;(ResSve.masc)=> "du" ++ ("har" ++ "blivit" ++ ("befordrad" ++ ("till" ++ Position @ 0.s ! ! ))) } ;(ResSve.pl)=> table ResSve.Sex {(ResSve.fem)=> "ni" ++ ("har" ++ "blivit" ++ ("befordrade" ++ ("till" ++ Position @ 0.s ! ! ))) ;(ResSve.masc)=> "ni" ++ ("har" ++ "blivit" ++ ("befordrade" ++ ("till" ++ Position @ 0.s ! ! ))) }}}}} ;"du (har blivit)befordrad till Position_0" ; lin ColleagueHe : Letter.Recipient = \ -> {s = "kollega" ;n = ;x = } ;"kollega" ; lin ColleagueShe : Letter.Recipient = \ -> {s = "kollega" ;n = ;x = } ;"kollega" ; @@ -182,13 +204,20 @@ lin Senior : Letter.Position = \ -> {s = table ResSve.Num {(ResSve.sg)(ResSve.pl lincat Sentence = {s : (ResSve.DepNum => (ResSve.Sex => (ResSve.Num => (ResSve.Sex => Str)))) }= {s = table ResSve.DepNum {(ResSve.depnum)(ResSve.cnum (ResSve.sg)) (ResSve.cnum (ResSve.pl)) => table ResSve.Sex {(ResSve.masc)(ResSve.fem)=> table ResSve.Num {(ResSve.sg)(ResSve.pl)=> table ResSve.Sex {(ResSve.masc)(ResSve.fem)=> str @ 0 }}}}} ;"Sentence" ; lin Spouse : Letter.Author = \ -> {s = table ResSve.Num {(ResSve.sg)=> table ResSve.Sex {(ResSve.masc)=> "din" ++ "hustru" ;(ResSve.fem)=> "din" ++ "man" } ;(ResSve.pl)=> table ResSve.Sex {(ResSve.masc)=> "era" ++ "hustrur" ;(ResSve.fem)=> "era" ++ "mn" }} ;n = ;x = } ;"din hustru" ; } -resource ResSve = {param DepNum = depnum | cnum ResSve.Num ; +resource ResSve = { +flags modulesize = n5 ; +param DepNum = depnum | cnum ResSve.Num ; param Gen = en | ett ; param Kas = nom | acc ; param Num = sg | pl ; param Sex = masc | fem ; } -concrete French of Letter = open ResFra in {flags startcat = Letter ;flags lexer = textlit ;flags unlexer = textlit ;lincat Author = {s : (ResFra.Num => (ResFra.Gen => Str)) ;n : ResFra.DepNum ;g : ResFra.DepGen }= {s = table ResFra.Num {(ResFra.sg)(ResFra.pl)=> table ResFra.Gen {(ResFra.masc)(ResFra.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; +concrete French of Letter = open ResFra in { +flags modulesize = n42 ; +flags startcat = Letter ; +flags lexer = textlit ; +flags unlexer = textlit ; +lincat Author = {s : (ResFra.Num => (ResFra.Gen => Str)) ;n : ResFra.DepNum ;g : ResFra.DepGen }= {s = table ResFra.Num {(ResFra.sg)(ResFra.pl)=> table ResFra.Gen {(ResFra.masc)(ResFra.fem)=> str @ 0 }} ;n = ;g = } ;"Author" ; lin BePromoted : Letter.Sentence = \ Position @ 0 -> {s = table ResFra.DepNum {(ResFra.depnum)(ResFra.cnum (ResFra.sg)) (ResFra.cnum (ResFra.pl)) => table ResFra.DepGen {(ResFra.depgen)(ResFra.cgen (ResFra.masc)) (ResFra.cgen (ResFra.fem)) => table ResFra.Num {(ResFra.pl)=> table ResFra.Gen {(ResFra.fem)=> "vous" ++ ("avez" ++ "t")++ ("promues" ++ Position @ 0.s ! ! ) ;(ResFra.masc)=> "vous" ++ ("avez" ++ "t")++ ("promus" ++ Position @ 0.s ! ! ) } ;(ResFra.sg)=> table ResFra.Gen {(ResFra.masc)=> "tu" ++ ("as" ++ "t")++ ("promu" ++ Position @ 0.s ! ! ) ;(ResFra.fem)=> "tu" ++ ("as" ++ "t")++ ("promue" ++ Position @ 0.s ! ! ) }}}}} ;"(tu as t)promu Position_0" ; lin ColleagueHe : Letter.Recipient = \ -> {s = "collgue" ;n = ;g = } ;"collgue" ; lin ColleagueShe : Letter.Recipient = \ -> {s = "collgue" ;n = ;g = } ;"collgue" ; @@ -231,13 +260,20 @@ lin Senior : Letter.Position = \ -> {s = table ResFra.Num {(ResFra.sg)=> table R lincat Sentence = {s : (ResFra.DepNum => (ResFra.DepGen => (ResFra.Num => (ResFra.Gen => Str)))) }= {s = table ResFra.DepNum {(ResFra.depnum)(ResFra.cnum (ResFra.sg)) (ResFra.cnum (ResFra.pl)) => table ResFra.DepGen {(ResFra.depgen)(ResFra.cgen (ResFra.masc)) (ResFra.cgen (ResFra.fem)) => table ResFra.Num {(ResFra.sg)(ResFra.pl)=> table ResFra.Gen {(ResFra.masc)(ResFra.fem)=> str @ 0 }}}}} ;"Sentence" ; lin Spouse : Letter.Author = \ -> {s = table ResFra.Num {(ResFra.sg)=> table ResFra.Gen {(ResFra.masc)=> "ta" ++ "femme" ;(ResFra.fem)=> "ton" ++ "mari" } ;(ResFra.pl)=> table ResFra.Gen {(ResFra.masc)=> "vos" ++ "femmes" ;(ResFra.fem)=> "vos" ++ "maris" }} ;n = ;g = } ;"ta femme" ; } -resource ResFra = {param DepGen = depgen | cgen ResFra.Gen ; +resource ResFra = { +flags modulesize = n5 ; +param DepGen = depgen | cgen ResFra.Gen ; param DepNum = depnum | cnum ResFra.Num ; param Gen = masc | fem ; param Kas = nom | acc ; param Num = sg | pl ; } -concrete English of Letter = open ResEng in {flags startcat = Letter ;flags lexer = textlit ;flags unlexer = textlit ;lincat Author = {s : (ResEng.Num => (ResEng.Sex => Str)) ;n : ResEng.DepNum ;x : ResEng.Sex }= {s = table ResEng.Num {(ResEng.sg)(ResEng.pl)=> table ResEng.Sex {(ResEng.masc)(ResEng.fem)=> str @ 0 }} ;n = ;x = } ;"Author" ; +concrete English of Letter = open ResEng in { +flags modulesize = n42 ; +flags startcat = Letter ; +flags lexer = textlit ; +flags unlexer = textlit ; +lincat Author = {s : (ResEng.Num => (ResEng.Sex => Str)) ;n : ResEng.DepNum ;x : ResEng.Sex }= {s = table ResEng.Num {(ResEng.sg)(ResEng.pl)=> table ResEng.Sex {(ResEng.masc)(ResEng.fem)=> str @ 0 }} ;n = ;x = } ;"Author" ; lin BePromoted : Letter.Sentence = \ Position @ 0 -> {s = table ResEng.DepNum {(ResEng.depnum)(ResEng.cnum (ResEng.sg)) (ResEng.cnum (ResEng.pl)) => table ResEng.Sex {(ResEng.masc)(ResEng.fem)=> table ResEng.Num {(ResEng.pl)=> table ResEng.Sex {(ResEng.fem)=> "you" ++ ("have" ++ ("been" ++ ("promoted" ++ "to")))++ Position @ 0.s ! ! ;(ResEng.masc)=> "you" ++ ("have" ++ ("been" ++ ("promoted" ++ "to")))++ Position @ 0.s ! ! } ;(ResEng.sg)=> table ResEng.Sex {(ResEng.fem)=> "you" ++ ("have" ++ ("been" ++ ("promoted" ++ "to")))++ Position @ 0.s ! ! ;(ResEng.masc)=> "you" ++ ("have" ++ ("been" ++ ("promoted" ++ "to")))++ Position @ 0.s ! ! }}}}} ;"(you have been promoted to)Position_0" ; lin ColleagueHe : Letter.Recipient = \ -> {s = "colleague" ;n = ;x = } ;"colleague" ; lin ColleagueShe : Letter.Recipient = \ -> {s = "colleague" ;n = ;x = } ;"colleague" ; @@ -280,7 +316,9 @@ lin Senior : Letter.Position = \ -> {s = table ResEng.Num {(ResEng.sg)=> table R lincat Sentence = {s : (ResEng.DepNum => (ResEng.Sex => (ResEng.Num => (ResEng.Sex => Str)))) }= {s = table ResEng.DepNum {(ResEng.depnum)(ResEng.cnum (ResEng.sg)) (ResEng.cnum (ResEng.pl)) => table ResEng.Sex {(ResEng.masc)(ResEng.fem)=> table ResEng.Num {(ResEng.sg)(ResEng.pl)=> table ResEng.Sex {(ResEng.masc)(ResEng.fem)=> str @ 0 }}}}} ;"Sentence" ; lin Spouse : Letter.Author = \ -> {s = table ResEng.Num {(ResEng.sg)=> table ResEng.Sex {(ResEng.fem)=> "your" ++ "husband" ;(ResEng.masc)=> "your" ++ "wife" } ;(ResEng.pl)=> table ResEng.Sex {(ResEng.fem)=> "your" ++ "husbands" ;(ResEng.masc)=> "your" ++ "wives" }} ;n = ;x = } ;"your wife" ; } -resource ResEng = {param DepNum = depnum | cnum ResEng.Num ; +resource ResEng = { +flags modulesize = n4 ; +param DepNum = depnum | cnum ResEng.Num ; param Kas = nom | acc ; param Num = sg | pl ; param Sex = masc | fem ; diff --git a/src/GF/Canon/AbsGFC.hs b/src/GF/Canon/AbsGFC.hs index 918338b18..0b8618877 100644 --- a/src/GF/Canon/AbsGFC.hs +++ b/src/GF/Canon/AbsGFC.hs @@ -1,4 +1,3 @@ - module GF.Canon.AbsGFC where import GF.Infra.Ident --H @@ -6,12 +5,19 @@ import GF.Infra.Ident --H -- Haskell module generated by the BNF converter, except --H -- newtype Ident = Ident String deriving (Eq,Ord,Show) --H - data Canon = MGr [Ident] Ident [Module] | Gr [Module] deriving (Eq,Ord,Show) +data Line = + LMulti [Ident] Ident + | LHeader ModType Extend Open + | LFlag Flag + | LDef Def + | LEnd + deriving (Eq,Ord,Show) + data Module = Mod ModType Extend Open [Flag] [Def] deriving (Eq,Ord,Show) @@ -131,8 +137,8 @@ data Term = data Tokn = KS String - | KM String | KP [String] [Variant] + | KM String deriving (Eq,Ord,Show) data Assign = diff --git a/src/GF/Canon/GFC.cf b/src/GF/Canon/GFC.cf index 7d258b38e..8c2490b64 100644 --- a/src/GF/Canon/GFC.cf +++ b/src/GF/Canon/GFC.cf @@ -2,11 +2,21 @@ -- Canonical GF. AR 27/4/2003 -entrypoints Canon ; +entrypoints Canon, Line ; + +-- old approach: read in a whole grammar MGr. Canon ::= "grammar" [Ident] "of" Ident ";" [Module] ; Gr. Canon ::= [Module] ; +-- new approach: read line by line + +LMulti. Line ::= "grammar" [Ident] "of" Ident ";" ; +LHeader. Line ::= ModType "=" Extend Open "{" ; +LFlag. Line ::= Flag ";" ; +LDef. Line ::= Def ";" ; +LEnd. Line ::= "}" ; + Mod. Module ::= ModType "=" Extend Open "{" [Flag] [Def] "}" ; MTAbs. ModType ::= "abstract" Ident ; diff --git a/src/GF/Canon/GetGFC.hs b/src/GF/Canon/GetGFC.hs index de476211f..cc22e4bff 100644 --- a/src/GF/Canon/GetGFC.hs +++ b/src/GF/Canon/GetGFC.hs @@ -5,9 +5,9 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/04/21 16:21:23 $ --- > CVS $Author: bringert $ --- > CVS $Revision: 1.7 $ +-- > CVS $Date: 2005/05/27 21:05:17 $ +-- > CVS $Author: aarne $ +-- > CVS $Revision: 1.8 $ -- -- (Description of the module) ----------------------------------------------------------------------------- @@ -22,6 +22,10 @@ import GF.Infra.Modules import GF.Compile.GetGrammar (err2err) --- import GF.Infra.UseIO +import System.IO +import System.Directory +import Control.Monad + getCanonModule :: FilePath -> IOE CanonModule getCanonModule file = do gr <- getCanonGrammar file @@ -32,6 +36,41 @@ getCanonModule file = do getCanonGrammar :: FilePath -> IOE CanonGrammar getCanonGrammar file = do s <- ioeIO $ readFileIf file - -- c <- ioeErr $ err2err $ pCanon $ myLexer s c <- ioeErr $ pCanon $ myLexer s return $ canon2grammar c + +-- the following surprisingly does not save memory so it is +-- not in use + +getCanonGrammarByLine :: FilePath -> IOE CanonGrammar +getCanonGrammarByLine file = do + b <- ioeIO $ doesFileExist file + if not b + then ioeErr $ Bad $ "file" +++ file +++ "does not exist" + else do + ioeIO $ putStrLn "" + hand <- ioeIO $ openFile file ReadMode ---- err + size <- ioeIO $ hFileSize hand + gr <- addNextLine (size,0) 1 hand emptyMGrammar + ioeIO $ hClose hand + return $ MGrammar $ reverse $ modules gr + + where + addNextLine (size,act) d hand gr = do + eof <- ioeIO $ hIsEOF hand + if eof + then return gr + else do + s <- ioeIO $ hGetLine hand + let act' = act + toInteger (length s) +-- if isHash act act' then (ioeIO $ putChar '#') else return () + updGrammar act' d gr $ pLine $ myLexer s + where + updGrammar a d gr (Ok t) = case buildCanonGrammar d gr t of + (gr',d') -> addNextLine (size,a) d' hand gr' + updGrammar _ _ gr (Bad s) = do + ioeIO $ putStrLn s + return emptyMGrammar + + isHash a b = a `div` step < b `div` step + step = size `div` 50 diff --git a/src/GF/Canon/MkGFC.hs b/src/GF/Canon/MkGFC.hs index 382eaf567..0868a2642 100644 --- a/src/GF/Canon/MkGFC.hs +++ b/src/GF/Canon/MkGFC.hs @@ -5,15 +5,15 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/04/21 16:21:26 $ --- > CVS $Author: bringert $ --- > CVS $Revision: 1.12 $ +-- > CVS $Date: 2005/05/27 21:05:17 $ +-- > CVS $Author: aarne $ +-- > CVS $Revision: 1.13 $ -- -- (Description of the module) ----------------------------------------------------------------------------- module GF.Canon.MkGFC (prCanonModInfo, prCanon, prCanonMGr, - canon2grammar, grammar2canon, + canon2grammar, grammar2canon, buildCanonGrammar, info2mod, trExp, rtExp, rtQIdent) where @@ -40,8 +40,9 @@ prCanonMGr g = header ++++ prCanon g where canon2grammar :: Canon -> CanonGrammar canon2grammar (MGr _ _ modules) = canon2grammar (Gr modules) ---- ignoring the header -canon2grammar (Gr modules) = M.MGrammar $ map mod2info modules where - mod2info m = case m of +canon2grammar (Gr modules) = M.MGrammar $ map mod2info modules + +mod2info m = case m of Mod mt e os flags defs -> let defs' = buildTree $ map def2info defs (a,mt') = case mt of @@ -50,6 +51,7 @@ canon2grammar (Gr modules) = M.MGrammar $ map mod2info modules where MTCnc a x -> (a,M.MTConcrete x) MTTrans a x y -> (a,M.MTTransfer (M.oSimple x) (M.oSimple y)) in (a,M.ModMod (M.Module mt' M.MSComplete flags (ee e) (oo os) defs')) + where ee (Ext m) = m ee _ = [] oo (Opens ms) = map M.oSimple ms @@ -170,3 +172,58 @@ rtQIdent (m,c) = CIQ (rtIdent m) (rtIdent c) rtIdent x | isWildIdent x = identC "h_" --- needed in declarations | otherwise = identC $ prt x --- + +-- the following is called in GetGFC to read gfc files line +-- by line. It does not save memory, though, and is therefore +-- not used. + +buildCanonGrammar :: Int -> CanonGrammar -> Line -> (CanonGrammar,Int) +buildCanonGrammar n gr0 line = mgr $ case line of +-- LMulti ids id + LHeader mt ext op -> newModule mt ext op + LFlag f@(Flg (IC "modulesize") (IC n)) -> initModule f $ read $ tail n + LFlag flag -> newFlag flag + LDef def -> newDef $ def2info def + LEnd -> cleanNames + _ -> M.modules gr0 + where + newModule mt ext op = mod2info (Mod mt ext op [] []) : mods + initModule f i = case actm of + (name, M.ModMod (M.Module mt com flags ee oo defs)) -> + (name, M.ModMod (M.Module mt com (f:flags) ee oo (newtree i))) : tmods + newFlag f = case actm of + (name, M.ModMod (M.Module mt com flags ee oo defs)) -> + (name, M.ModMod (M.Module mt com (f:flags) ee oo defs)) : tmods + newDef d = case actm of + (name, M.ModMod (M.Module mt com flags ee oo defs)) -> + (name, M.ModMod (M.Module mt com flags ee oo + (upd (padd 8 n) d defs))) : tmods + cleanNames = case actm of + (name, M.ModMod (M.Module mt com flags ee oo defs)) -> + (name, M.ModMod (M.Module mt com (reverse flags) ee oo + (mapTree (\ (IC f,t) -> (IC (drop 8 f),t)) defs))) : tmods + + actm = head mods -- only used when a new mod has been created + mods = M.modules gr0 + tmods = tail mods + + mgr ms = (M.MGrammar ms, case line of + LDef _ -> n+1 + LEnd -> 1 + _ -> n + ) + + -- create an initial tree with who-cares value + newtree (i :: Int) = sorted2tree [ + (padd 8 k, ResPar []) | + k <- [1..i]] --- padd (length (show i)) + + padd l k = let sk = show k in identC (replicate (l - length sk) '0' ++ sk) + + upd n d@(f,t) defs = case defs of + NT -> BT (merg n f,t) NT NT --- should not happen + BT c@(a,_) left right + | n < a -> let left' = upd n d left in BT c left' right + | n > a -> let right' = upd n d right in BT c left right' + | otherwise -> BT (merg n f,t) left right + merg (IC n) (IC f) = IC (n ++ f) diff --git a/src/GF/Canon/ParGFC.hs b/src/GF/Canon/ParGFC.hs index 84e93a327..9fbb39c83 100644 --- a/src/GF/Canon/ParGFC.hs +++ b/src/GF/Canon/ParGFC.hs @@ -1,6 +1,4 @@ {-# OPTIONS -fglasgow-exts -cpp #-} --- parser produced by Happy Version 1.13 - module GF.Canon.ParGFC where import GF.Canon.AbsGFC import GF.Canon.LexGFC @@ -13,349 +11,356 @@ import GHC.Exts import GlaExts #endif -newtype HappyAbsSyn t4 t5 t6 = HappyAbsSyn (() -> ()) -happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6) -happyIn4 x = unsafeCoerce# x -{-# INLINE happyIn4 #-} -happyOut4 :: (HappyAbsSyn t4 t5 t6) -> t4 -happyOut4 x = unsafeCoerce# x -{-# INLINE happyOut4 #-} -happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6) +-- parser produced by Happy Version 1.15 + +newtype HappyAbsSyn = HappyAbsSyn (() -> ()) +happyIn5 :: (Ident) -> (HappyAbsSyn ) happyIn5 x = unsafeCoerce# x {-# INLINE happyIn5 #-} -happyOut5 :: (HappyAbsSyn t4 t5 t6) -> t5 +happyOut5 :: (HappyAbsSyn ) -> (Ident) happyOut5 x = unsafeCoerce# x {-# INLINE happyOut5 #-} -happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6) +happyIn6 :: (String) -> (HappyAbsSyn ) happyIn6 x = unsafeCoerce# x {-# INLINE happyIn6 #-} -happyOut6 :: (HappyAbsSyn t4 t5 t6) -> t6 +happyOut6 :: (HappyAbsSyn ) -> (String) happyOut6 x = unsafeCoerce# x {-# INLINE happyOut6 #-} -happyIn7 :: (Canon) -> (HappyAbsSyn t4 t5 t6) +happyIn7 :: (Integer) -> (HappyAbsSyn ) happyIn7 x = unsafeCoerce# x {-# INLINE happyIn7 #-} -happyOut7 :: (HappyAbsSyn t4 t5 t6) -> (Canon) +happyOut7 :: (HappyAbsSyn ) -> (Integer) happyOut7 x = unsafeCoerce# x {-# INLINE happyOut7 #-} -happyIn8 :: (Module) -> (HappyAbsSyn t4 t5 t6) +happyIn8 :: (Canon) -> (HappyAbsSyn ) happyIn8 x = unsafeCoerce# x {-# INLINE happyIn8 #-} -happyOut8 :: (HappyAbsSyn t4 t5 t6) -> (Module) +happyOut8 :: (HappyAbsSyn ) -> (Canon) happyOut8 x = unsafeCoerce# x {-# INLINE happyOut8 #-} -happyIn9 :: (ModType) -> (HappyAbsSyn t4 t5 t6) +happyIn9 :: (Line) -> (HappyAbsSyn ) happyIn9 x = unsafeCoerce# x {-# INLINE happyIn9 #-} -happyOut9 :: (HappyAbsSyn t4 t5 t6) -> (ModType) +happyOut9 :: (HappyAbsSyn ) -> (Line) happyOut9 x = unsafeCoerce# x {-# INLINE happyOut9 #-} -happyIn10 :: ([Module]) -> (HappyAbsSyn t4 t5 t6) +happyIn10 :: (Module) -> (HappyAbsSyn ) happyIn10 x = unsafeCoerce# x {-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn t4 t5 t6) -> ([Module]) +happyOut10 :: (HappyAbsSyn ) -> (Module) happyOut10 x = unsafeCoerce# x {-# INLINE happyOut10 #-} -happyIn11 :: (Extend) -> (HappyAbsSyn t4 t5 t6) +happyIn11 :: (ModType) -> (HappyAbsSyn ) happyIn11 x = unsafeCoerce# x {-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn t4 t5 t6) -> (Extend) +happyOut11 :: (HappyAbsSyn ) -> (ModType) happyOut11 x = unsafeCoerce# x {-# INLINE happyOut11 #-} -happyIn12 :: (Open) -> (HappyAbsSyn t4 t5 t6) +happyIn12 :: ([Module]) -> (HappyAbsSyn ) happyIn12 x = unsafeCoerce# x {-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn t4 t5 t6) -> (Open) +happyOut12 :: (HappyAbsSyn ) -> ([Module]) happyOut12 x = unsafeCoerce# x {-# INLINE happyOut12 #-} -happyIn13 :: (Flag) -> (HappyAbsSyn t4 t5 t6) +happyIn13 :: (Extend) -> (HappyAbsSyn ) happyIn13 x = unsafeCoerce# x {-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn t4 t5 t6) -> (Flag) +happyOut13 :: (HappyAbsSyn ) -> (Extend) happyOut13 x = unsafeCoerce# x {-# INLINE happyOut13 #-} -happyIn14 :: (Def) -> (HappyAbsSyn t4 t5 t6) +happyIn14 :: (Open) -> (HappyAbsSyn ) happyIn14 x = unsafeCoerce# x {-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn t4 t5 t6) -> (Def) +happyOut14 :: (HappyAbsSyn ) -> (Open) happyOut14 x = unsafeCoerce# x {-# INLINE happyOut14 #-} -happyIn15 :: (ParDef) -> (HappyAbsSyn t4 t5 t6) +happyIn15 :: (Flag) -> (HappyAbsSyn ) happyIn15 x = unsafeCoerce# x {-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn t4 t5 t6) -> (ParDef) +happyOut15 :: (HappyAbsSyn ) -> (Flag) happyOut15 x = unsafeCoerce# x {-# INLINE happyOut15 #-} -happyIn16 :: (Status) -> (HappyAbsSyn t4 t5 t6) +happyIn16 :: (Def) -> (HappyAbsSyn ) happyIn16 x = unsafeCoerce# x {-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn t4 t5 t6) -> (Status) +happyOut16 :: (HappyAbsSyn ) -> (Def) happyOut16 x = unsafeCoerce# x {-# INLINE happyOut16 #-} -happyIn17 :: (CIdent) -> (HappyAbsSyn t4 t5 t6) +happyIn17 :: (ParDef) -> (HappyAbsSyn ) happyIn17 x = unsafeCoerce# x {-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn t4 t5 t6) -> (CIdent) +happyOut17 :: (HappyAbsSyn ) -> (ParDef) happyOut17 x = unsafeCoerce# x {-# INLINE happyOut17 #-} -happyIn18 :: (Exp) -> (HappyAbsSyn t4 t5 t6) +happyIn18 :: (Status) -> (HappyAbsSyn ) happyIn18 x = unsafeCoerce# x {-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn t4 t5 t6) -> (Exp) +happyOut18 :: (HappyAbsSyn ) -> (Status) happyOut18 x = unsafeCoerce# x {-# INLINE happyOut18 #-} -happyIn19 :: (Exp) -> (HappyAbsSyn t4 t5 t6) +happyIn19 :: (CIdent) -> (HappyAbsSyn ) happyIn19 x = unsafeCoerce# x {-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn t4 t5 t6) -> (Exp) +happyOut19 :: (HappyAbsSyn ) -> (CIdent) happyOut19 x = unsafeCoerce# x {-# INLINE happyOut19 #-} -happyIn20 :: (Exp) -> (HappyAbsSyn t4 t5 t6) +happyIn20 :: (Exp) -> (HappyAbsSyn ) happyIn20 x = unsafeCoerce# x {-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn t4 t5 t6) -> (Exp) +happyOut20 :: (HappyAbsSyn ) -> (Exp) happyOut20 x = unsafeCoerce# x {-# INLINE happyOut20 #-} -happyIn21 :: (Sort) -> (HappyAbsSyn t4 t5 t6) +happyIn21 :: (Exp) -> (HappyAbsSyn ) happyIn21 x = unsafeCoerce# x {-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn t4 t5 t6) -> (Sort) +happyOut21 :: (HappyAbsSyn ) -> (Exp) happyOut21 x = unsafeCoerce# x {-# INLINE happyOut21 #-} -happyIn22 :: (Equation) -> (HappyAbsSyn t4 t5 t6) +happyIn22 :: (Exp) -> (HappyAbsSyn ) happyIn22 x = unsafeCoerce# x {-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn t4 t5 t6) -> (Equation) +happyOut22 :: (HappyAbsSyn ) -> (Exp) happyOut22 x = unsafeCoerce# x {-# INLINE happyOut22 #-} -happyIn23 :: (APatt) -> (HappyAbsSyn t4 t5 t6) +happyIn23 :: (Sort) -> (HappyAbsSyn ) happyIn23 x = unsafeCoerce# x {-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn t4 t5 t6) -> (APatt) +happyOut23 :: (HappyAbsSyn ) -> (Sort) happyOut23 x = unsafeCoerce# x {-# INLINE happyOut23 #-} -happyIn24 :: ([Decl]) -> (HappyAbsSyn t4 t5 t6) +happyIn24 :: (Equation) -> (HappyAbsSyn ) happyIn24 x = unsafeCoerce# x {-# INLINE happyIn24 #-} -happyOut24 :: (HappyAbsSyn t4 t5 t6) -> ([Decl]) +happyOut24 :: (HappyAbsSyn ) -> (Equation) happyOut24 x = unsafeCoerce# x {-# INLINE happyOut24 #-} -happyIn25 :: ([APatt]) -> (HappyAbsSyn t4 t5 t6) +happyIn25 :: (APatt) -> (HappyAbsSyn ) happyIn25 x = unsafeCoerce# x {-# INLINE happyIn25 #-} -happyOut25 :: (HappyAbsSyn t4 t5 t6) -> ([APatt]) +happyOut25 :: (HappyAbsSyn ) -> (APatt) happyOut25 x = unsafeCoerce# x {-# INLINE happyOut25 #-} -happyIn26 :: ([Equation]) -> (HappyAbsSyn t4 t5 t6) +happyIn26 :: ([Decl]) -> (HappyAbsSyn ) happyIn26 x = unsafeCoerce# x {-# INLINE happyIn26 #-} -happyOut26 :: (HappyAbsSyn t4 t5 t6) -> ([Equation]) +happyOut26 :: (HappyAbsSyn ) -> ([Decl]) happyOut26 x = unsafeCoerce# x {-# INLINE happyOut26 #-} -happyIn27 :: (Atom) -> (HappyAbsSyn t4 t5 t6) +happyIn27 :: ([APatt]) -> (HappyAbsSyn ) happyIn27 x = unsafeCoerce# x {-# INLINE happyIn27 #-} -happyOut27 :: (HappyAbsSyn t4 t5 t6) -> (Atom) +happyOut27 :: (HappyAbsSyn ) -> ([APatt]) happyOut27 x = unsafeCoerce# x {-# INLINE happyOut27 #-} -happyIn28 :: (Decl) -> (HappyAbsSyn t4 t5 t6) +happyIn28 :: ([Equation]) -> (HappyAbsSyn ) happyIn28 x = unsafeCoerce# x {-# INLINE happyIn28 #-} -happyOut28 :: (HappyAbsSyn t4 t5 t6) -> (Decl) +happyOut28 :: (HappyAbsSyn ) -> ([Equation]) happyOut28 x = unsafeCoerce# x {-# INLINE happyOut28 #-} -happyIn29 :: (CType) -> (HappyAbsSyn t4 t5 t6) +happyIn29 :: (Atom) -> (HappyAbsSyn ) happyIn29 x = unsafeCoerce# x {-# INLINE happyIn29 #-} -happyOut29 :: (HappyAbsSyn t4 t5 t6) -> (CType) +happyOut29 :: (HappyAbsSyn ) -> (Atom) happyOut29 x = unsafeCoerce# x {-# INLINE happyOut29 #-} -happyIn30 :: (Labelling) -> (HappyAbsSyn t4 t5 t6) +happyIn30 :: (Decl) -> (HappyAbsSyn ) happyIn30 x = unsafeCoerce# x {-# INLINE happyIn30 #-} -happyOut30 :: (HappyAbsSyn t4 t5 t6) -> (Labelling) +happyOut30 :: (HappyAbsSyn ) -> (Decl) happyOut30 x = unsafeCoerce# x {-# INLINE happyOut30 #-} -happyIn31 :: (Term) -> (HappyAbsSyn t4 t5 t6) +happyIn31 :: (CType) -> (HappyAbsSyn ) happyIn31 x = unsafeCoerce# x {-# INLINE happyIn31 #-} -happyOut31 :: (HappyAbsSyn t4 t5 t6) -> (Term) +happyOut31 :: (HappyAbsSyn ) -> (CType) happyOut31 x = unsafeCoerce# x {-# INLINE happyOut31 #-} -happyIn32 :: (Term) -> (HappyAbsSyn t4 t5 t6) +happyIn32 :: (Labelling) -> (HappyAbsSyn ) happyIn32 x = unsafeCoerce# x {-# INLINE happyIn32 #-} -happyOut32 :: (HappyAbsSyn t4 t5 t6) -> (Term) +happyOut32 :: (HappyAbsSyn ) -> (Labelling) happyOut32 x = unsafeCoerce# x {-# INLINE happyOut32 #-} -happyIn33 :: (Term) -> (HappyAbsSyn t4 t5 t6) +happyIn33 :: (Term) -> (HappyAbsSyn ) happyIn33 x = unsafeCoerce# x {-# INLINE happyIn33 #-} -happyOut33 :: (HappyAbsSyn t4 t5 t6) -> (Term) +happyOut33 :: (HappyAbsSyn ) -> (Term) happyOut33 x = unsafeCoerce# x {-# INLINE happyOut33 #-} -happyIn34 :: (Tokn) -> (HappyAbsSyn t4 t5 t6) +happyIn34 :: (Term) -> (HappyAbsSyn ) happyIn34 x = unsafeCoerce# x {-# INLINE happyIn34 #-} -happyOut34 :: (HappyAbsSyn t4 t5 t6) -> (Tokn) +happyOut34 :: (HappyAbsSyn ) -> (Term) happyOut34 x = unsafeCoerce# x {-# INLINE happyOut34 #-} -happyIn35 :: (Assign) -> (HappyAbsSyn t4 t5 t6) +happyIn35 :: (Term) -> (HappyAbsSyn ) happyIn35 x = unsafeCoerce# x {-# INLINE happyIn35 #-} -happyOut35 :: (HappyAbsSyn t4 t5 t6) -> (Assign) +happyOut35 :: (HappyAbsSyn ) -> (Term) happyOut35 x = unsafeCoerce# x {-# INLINE happyOut35 #-} -happyIn36 :: (Case) -> (HappyAbsSyn t4 t5 t6) +happyIn36 :: (Tokn) -> (HappyAbsSyn ) happyIn36 x = unsafeCoerce# x {-# INLINE happyIn36 #-} -happyOut36 :: (HappyAbsSyn t4 t5 t6) -> (Case) +happyOut36 :: (HappyAbsSyn ) -> (Tokn) happyOut36 x = unsafeCoerce# x {-# INLINE happyOut36 #-} -happyIn37 :: (Variant) -> (HappyAbsSyn t4 t5 t6) +happyIn37 :: (Assign) -> (HappyAbsSyn ) happyIn37 x = unsafeCoerce# x {-# INLINE happyIn37 #-} -happyOut37 :: (HappyAbsSyn t4 t5 t6) -> (Variant) +happyOut37 :: (HappyAbsSyn ) -> (Assign) happyOut37 x = unsafeCoerce# x {-# INLINE happyOut37 #-} -happyIn38 :: (Label) -> (HappyAbsSyn t4 t5 t6) +happyIn38 :: (Case) -> (HappyAbsSyn ) happyIn38 x = unsafeCoerce# x {-# INLINE happyIn38 #-} -happyOut38 :: (HappyAbsSyn t4 t5 t6) -> (Label) +happyOut38 :: (HappyAbsSyn ) -> (Case) happyOut38 x = unsafeCoerce# x {-# INLINE happyOut38 #-} -happyIn39 :: (ArgVar) -> (HappyAbsSyn t4 t5 t6) +happyIn39 :: (Variant) -> (HappyAbsSyn ) happyIn39 x = unsafeCoerce# x {-# INLINE happyIn39 #-} -happyOut39 :: (HappyAbsSyn t4 t5 t6) -> (ArgVar) +happyOut39 :: (HappyAbsSyn ) -> (Variant) happyOut39 x = unsafeCoerce# x {-# INLINE happyOut39 #-} -happyIn40 :: (Patt) -> (HappyAbsSyn t4 t5 t6) +happyIn40 :: (Label) -> (HappyAbsSyn ) happyIn40 x = unsafeCoerce# x {-# INLINE happyIn40 #-} -happyOut40 :: (HappyAbsSyn t4 t5 t6) -> (Patt) +happyOut40 :: (HappyAbsSyn ) -> (Label) happyOut40 x = unsafeCoerce# x {-# INLINE happyOut40 #-} -happyIn41 :: (PattAssign) -> (HappyAbsSyn t4 t5 t6) +happyIn41 :: (ArgVar) -> (HappyAbsSyn ) happyIn41 x = unsafeCoerce# x {-# INLINE happyIn41 #-} -happyOut41 :: (HappyAbsSyn t4 t5 t6) -> (PattAssign) +happyOut41 :: (HappyAbsSyn ) -> (ArgVar) happyOut41 x = unsafeCoerce# x {-# INLINE happyOut41 #-} -happyIn42 :: ([Flag]) -> (HappyAbsSyn t4 t5 t6) +happyIn42 :: (Patt) -> (HappyAbsSyn ) happyIn42 x = unsafeCoerce# x {-# INLINE happyIn42 #-} -happyOut42 :: (HappyAbsSyn t4 t5 t6) -> ([Flag]) +happyOut42 :: (HappyAbsSyn ) -> (Patt) happyOut42 x = unsafeCoerce# x {-# INLINE happyOut42 #-} -happyIn43 :: ([Def]) -> (HappyAbsSyn t4 t5 t6) +happyIn43 :: (PattAssign) -> (HappyAbsSyn ) happyIn43 x = unsafeCoerce# x {-# INLINE happyIn43 #-} -happyOut43 :: (HappyAbsSyn t4 t5 t6) -> ([Def]) +happyOut43 :: (HappyAbsSyn ) -> (PattAssign) happyOut43 x = unsafeCoerce# x {-# INLINE happyOut43 #-} -happyIn44 :: ([ParDef]) -> (HappyAbsSyn t4 t5 t6) +happyIn44 :: ([Flag]) -> (HappyAbsSyn ) happyIn44 x = unsafeCoerce# x {-# INLINE happyIn44 #-} -happyOut44 :: (HappyAbsSyn t4 t5 t6) -> ([ParDef]) +happyOut44 :: (HappyAbsSyn ) -> ([Flag]) happyOut44 x = unsafeCoerce# x {-# INLINE happyOut44 #-} -happyIn45 :: ([CType]) -> (HappyAbsSyn t4 t5 t6) +happyIn45 :: ([Def]) -> (HappyAbsSyn ) happyIn45 x = unsafeCoerce# x {-# INLINE happyIn45 #-} -happyOut45 :: (HappyAbsSyn t4 t5 t6) -> ([CType]) +happyOut45 :: (HappyAbsSyn ) -> ([Def]) happyOut45 x = unsafeCoerce# x {-# INLINE happyOut45 #-} -happyIn46 :: ([CIdent]) -> (HappyAbsSyn t4 t5 t6) +happyIn46 :: ([ParDef]) -> (HappyAbsSyn ) happyIn46 x = unsafeCoerce# x {-# INLINE happyIn46 #-} -happyOut46 :: (HappyAbsSyn t4 t5 t6) -> ([CIdent]) +happyOut46 :: (HappyAbsSyn ) -> ([ParDef]) happyOut46 x = unsafeCoerce# x {-# INLINE happyOut46 #-} -happyIn47 :: ([Assign]) -> (HappyAbsSyn t4 t5 t6) +happyIn47 :: ([CType]) -> (HappyAbsSyn ) happyIn47 x = unsafeCoerce# x {-# INLINE happyIn47 #-} -happyOut47 :: (HappyAbsSyn t4 t5 t6) -> ([Assign]) +happyOut47 :: (HappyAbsSyn ) -> ([CType]) happyOut47 x = unsafeCoerce# x {-# INLINE happyOut47 #-} -happyIn48 :: ([ArgVar]) -> (HappyAbsSyn t4 t5 t6) +happyIn48 :: ([CIdent]) -> (HappyAbsSyn ) happyIn48 x = unsafeCoerce# x {-# INLINE happyIn48 #-} -happyOut48 :: (HappyAbsSyn t4 t5 t6) -> ([ArgVar]) +happyOut48 :: (HappyAbsSyn ) -> ([CIdent]) happyOut48 x = unsafeCoerce# x {-# INLINE happyOut48 #-} -happyIn49 :: ([Labelling]) -> (HappyAbsSyn t4 t5 t6) +happyIn49 :: ([Assign]) -> (HappyAbsSyn ) happyIn49 x = unsafeCoerce# x {-# INLINE happyIn49 #-} -happyOut49 :: (HappyAbsSyn t4 t5 t6) -> ([Labelling]) +happyOut49 :: (HappyAbsSyn ) -> ([Assign]) happyOut49 x = unsafeCoerce# x {-# INLINE happyOut49 #-} -happyIn50 :: ([Case]) -> (HappyAbsSyn t4 t5 t6) +happyIn50 :: ([ArgVar]) -> (HappyAbsSyn ) happyIn50 x = unsafeCoerce# x {-# INLINE happyIn50 #-} -happyOut50 :: (HappyAbsSyn t4 t5 t6) -> ([Case]) +happyOut50 :: (HappyAbsSyn ) -> ([ArgVar]) happyOut50 x = unsafeCoerce# x {-# INLINE happyOut50 #-} -happyIn51 :: ([Term]) -> (HappyAbsSyn t4 t5 t6) +happyIn51 :: ([Labelling]) -> (HappyAbsSyn ) happyIn51 x = unsafeCoerce# x {-# INLINE happyIn51 #-} -happyOut51 :: (HappyAbsSyn t4 t5 t6) -> ([Term]) +happyOut51 :: (HappyAbsSyn ) -> ([Labelling]) happyOut51 x = unsafeCoerce# x {-# INLINE happyOut51 #-} -happyIn52 :: ([String]) -> (HappyAbsSyn t4 t5 t6) +happyIn52 :: ([Case]) -> (HappyAbsSyn ) happyIn52 x = unsafeCoerce# x {-# INLINE happyIn52 #-} -happyOut52 :: (HappyAbsSyn t4 t5 t6) -> ([String]) +happyOut52 :: (HappyAbsSyn ) -> ([Case]) happyOut52 x = unsafeCoerce# x {-# INLINE happyOut52 #-} -happyIn53 :: ([Variant]) -> (HappyAbsSyn t4 t5 t6) +happyIn53 :: ([Term]) -> (HappyAbsSyn ) happyIn53 x = unsafeCoerce# x {-# INLINE happyIn53 #-} -happyOut53 :: (HappyAbsSyn t4 t5 t6) -> ([Variant]) +happyOut53 :: (HappyAbsSyn ) -> ([Term]) happyOut53 x = unsafeCoerce# x {-# INLINE happyOut53 #-} -happyIn54 :: ([PattAssign]) -> (HappyAbsSyn t4 t5 t6) +happyIn54 :: ([String]) -> (HappyAbsSyn ) happyIn54 x = unsafeCoerce# x {-# INLINE happyIn54 #-} -happyOut54 :: (HappyAbsSyn t4 t5 t6) -> ([PattAssign]) +happyOut54 :: (HappyAbsSyn ) -> ([String]) happyOut54 x = unsafeCoerce# x {-# INLINE happyOut54 #-} -happyIn55 :: ([Patt]) -> (HappyAbsSyn t4 t5 t6) +happyIn55 :: ([Variant]) -> (HappyAbsSyn ) happyIn55 x = unsafeCoerce# x {-# INLINE happyIn55 #-} -happyOut55 :: (HappyAbsSyn t4 t5 t6) -> ([Patt]) +happyOut55 :: (HappyAbsSyn ) -> ([Variant]) happyOut55 x = unsafeCoerce# x {-# INLINE happyOut55 #-} -happyIn56 :: ([Ident]) -> (HappyAbsSyn t4 t5 t6) +happyIn56 :: ([PattAssign]) -> (HappyAbsSyn ) happyIn56 x = unsafeCoerce# x {-# INLINE happyIn56 #-} -happyOut56 :: (HappyAbsSyn t4 t5 t6) -> ([Ident]) +happyOut56 :: (HappyAbsSyn ) -> ([PattAssign]) happyOut56 x = unsafeCoerce# x {-# INLINE happyOut56 #-} -happyInTok :: Token -> (HappyAbsSyn t4 t5 t6) +happyIn57 :: ([Patt]) -> (HappyAbsSyn ) +happyIn57 x = unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> ([Patt]) +happyOut57 x = unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: ([Ident]) -> (HappyAbsSyn ) +happyIn58 x = unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> ([Ident]) +happyOut58 x = unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyInTok :: Token -> (HappyAbsSyn ) happyInTok x = unsafeCoerce# x {-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn t4 t5 t6) -> Token +happyOutTok :: (HappyAbsSyn ) -> Token happyOutTok x = unsafeCoerce# x {-# INLINE happyOutTok #-} happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x2d\x02\x25\x02\x00\x00\x22\x02\x47\x01\x21\x02\x34\x02\x27\x02\x00\x00\x49\x02\x1f\x02\x1f\x02\x1f\x02\x1f\x02\x48\x02\x00\x00\x24\x02\x00\x00\x1c\x00\x19\x02\x19\x02\x00\x00\x46\x02\x20\x02\x41\x02\x15\x02\x15\x02\x3f\x02\x00\x00\x00\x00\x40\x02\x13\x02\x00\x00\x47\x01\x1d\x02\x00\x00\x10\x02\x00\x00\x1e\x02\x00\x00\x3d\x02\x7d\x00\x0e\x02\x3b\x02\x1a\x02\x38\x02\x00\x00\x0b\x02\x0b\x02\x0b\x02\x0b\x02\x0b\x02\x0b\x02\x0b\x02\x00\x00\x36\x02\x35\x02\x31\x02\x33\x02\x2c\x02\x2a\x02\x26\x02\x00\x00\x08\x02\x00\x00\xf6\x01\x00\x00\xf6\x01\xf6\x01\x10\x00\xf6\x01\x61\x00\x61\x00\xf6\x01\x10\x00\x17\x02\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x01\x10\x00\xf0\x01\xf0\x01\xf3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x02\x00\x00\x00\x00\x1c\x02\xf9\xff\x61\x00\xe2\x01\x00\x00\x12\x02\x11\x02\x0f\x02\x0d\x02\x07\x02\x0c\x02\x00\x00\xde\x01\x0a\x02\x10\x00\x10\x00\xf9\x01\x0c\x00\x00\x00\xef\x01\x00\x00\xff\x01\xfc\x01\xfb\x01\xcb\x01\x0c\x00\xcc\x01\x61\x00\x00\x00\x00\x00\xea\x01\x0c\x01\xee\x01\xeb\x01\xec\x01\x00\x00\x10\x00\xbe\x01\x00\x00\xed\x01\x80\x00\x00\x00\x10\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x66\x01\x00\x00\x00\x00\x00\x00\xdd\x01\xd7\x01\xd4\x01\x00\x00\x00\x00\xf9\xff\x08\x00\x0c\x00\xbc\x01\xbc\x01\x61\x00\xdc\x01\x00\x00\x00\x00\x61\x00\xf9\xff\x61\x00\xa1\x00\xbb\x01\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\xbe\x00\xc4\x01\xd6\x01\x0c\x00\x0c\x00\xce\x01\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\xd8\x01\xd5\x01\xd2\x01\x57\x00\xf9\xff\xaa\x01\xaa\x01\xba\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\xa9\x01\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x01\xb6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\xf9\xff\x12\x00\x00\x00\x4d\x00\xc7\x01\x00\x00\x47\x00\x00\x00\xb5\x01\xb3\x01\x0c\x00\x99\x01\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x3d\x00\xc3\x01\xb7\x01\x68\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xb0\x01\x87\x01\x10\x00\x9d\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x8b\x00\xb4\x01\x00\x00\x00\x00\x00\x00\xf9\xff\x86\x01\x00\x00\x0c\x00\x00\x00\xb2\x01\x00\x00\x0c\x00\xa0\x01\x00\x00\xa0\x01\x00\x00\xb1\x01\xa8\x01\xae\x01\x9f\x01\x00\x00\x5b\x00\x00\x00\x75\x01\x00\x00\x00\x00\xf9\xff\x67\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00"# +happyActOffsets = HappyA# "\x5b\x02\x83\x00\x55\x02\x00\x00\x53\x02\x4d\x02\x70\x02\x6e\x02\x6b\x02\x00\x00\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x49\x02\x46\x02\x8a\x01\x42\x02\x54\x02\x45\x02\x00\x00\x69\x02\x40\x02\xe4\x00\x00\x00\x67\x02\x65\x02\x64\x02\x63\x02\x3f\x02\x60\x02\x61\x02\x39\x02\x5a\x02\x00\x00\x00\x00\x00\x00\x1d\x00\x3a\x02\x00\x00\x33\x02\x35\x02\x59\x02\x2c\x02\x2c\x02\x2c\x02\x0f\x00\x2c\x02\x2c\x02\x67\x00\x67\x00\x2c\x02\x0f\x00\x2c\x02\x57\x02\x1d\x00\x29\x02\x29\x02\x00\x00\x58\x02\x32\x02\x51\x02\x4b\x02\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x02\x0f\x00\x1f\x02\x1f\x02\x25\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x02\x00\x00\x00\x00\x52\x02\xf6\xff\x67\x00\x20\x02\x00\x00\x50\x02\x4f\x02\x4e\x02\x4c\x02\x00\x00\x00\x00\x48\x02\x43\x02\x4a\x02\x00\x00\x47\x02\x18\x02\x00\x00\x23\x02\x00\x00\x16\x02\x44\x02\x0f\x00\x0f\x00\x00\x00\x3b\x02\x17\x00\x00\x00\x31\x02\x00\x00\x41\x02\x3e\x02\x3d\x02\x0d\x02\x17\x00\x0e\x02\x67\x00\x00\x00\x00\x00\x2e\x02\x12\x00\x30\x02\x36\x02\x37\x02\x00\x00\x0f\x00\x07\x02\x07\x02\x34\x02\x00\x00\x8a\x01\x00\x00\x00\x00\x00\x00\x27\x02\x8d\x00\x00\x00\x0f\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x49\x01\x00\x00\x00\x00\x00\x00\x26\x02\x22\x02\x1d\x02\x00\x00\x00\x00\xf6\xff\x4e\x00\x17\x00\xff\x01\xff\x01\x67\x00\x24\x02\x00\x00\x00\x00\x67\x00\xf6\xff\x67\x00\xc6\x00\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x01\xf7\x00\x0b\x02\x1e\x02\x17\x00\x17\x00\x13\x02\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x14\x02\x12\x02\x03\x02\x5d\x00\xf6\xff\xd5\x01\xd5\x01\xf7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\xd4\x01\x00\x00\x00\x00\xe4\x01\xf6\x01\x92\x00\x00\x00\x00\x00\xfc\x01\xea\x01\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\xf6\xff\x0a\x00\x00\x00\x53\x00\xf1\x01\x00\x00\x4d\x00\x00\x00\xe2\x01\xde\x01\x17\x00\xc3\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x43\x00\xe9\x01\xe3\x01\x5a\x00\x00\x00\x00\x00\x72\x00\x00\x00\xd3\x01\xb6\x01\x0f\x00\xbc\x00\xe5\x01\x00\x00\xb3\x01\x00\x00\xe1\x01\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x01\x4b\x00\xd2\x01\x00\x00\x00\x00\x00\x00\xf6\xff\x9b\x01\x00\x00\x17\x00\x00\x00\xd1\x01\x00\x00\x17\x00\xb5\x01\x00\x00\xb5\x01\x00\x00\xc9\x01\xc8\x01\xb4\x01\xbd\x01\x00\x00\xfb\xff\x00\x00\x93\x01\x00\x00\x00\x00\xf6\xff\x64\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00"# happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\x13\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\xa5\x01\xa4\x01\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\xa1\x01\x03\x00\x00\x00\x00\x00\x98\x01\x00\x00\x97\x01\x96\x01\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x8f\x01\xbf\x00\x00\x00\x6e\x01\x91\x01\x00\x00\x3e\x00\x00\x00\x00\x00\x05\x01\x83\x01\x00\x00\x5a\x01\x00\x00\x00\x00\x81\x01\x73\x01\x6f\x01\x69\x01\x5d\x01\x56\x01\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x01\x00\x00\x4c\x01\x33\x01\x1b\x02\x85\x01\x5f\x01\x5e\x01\x93\x00\x09\x02\x00\x00\x00\x00\x00\x00\x00\x00\x23\x02\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x01\x3b\x01\xf7\x01\x82\x01\x35\x01\x2a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x57\x01\x28\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\xe5\x01\xd3\x01\x00\x00\x37\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x01\x25\x01\x77\x00\x2d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\x00\x00\xc1\x01\x23\x01\x00\x00\x00\x00\x0b\x00\x00\x00\xaf\x01\x00\x00\x9d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x13\x01\x68\x01\x21\x01\x1b\x01\x00\x00\x00\x00\x00\x00\x09\x01\x06\x00\xf7\x00\x00\x00\x2f\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x3c\x01\x00\x00\x00\x00\x00\x00\x01\x01\x3d\x01\x00\x00\x00\x00\x00\x00\xea\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x61\x01\x84\x00\x06\x01\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x01\xf2\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\x05\x00\xf3\x00\x00\x00\x4f\x01\x60\x01\x89\x00\x4f\x01\x00\x00\x00\x00\x00\x00\xdd\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x00\x00\xae\x00\x79\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\xb5\x00\x00\x00\xca\x00\x00\x00\x9f\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x00\xbb\x00\x00\x00\x16\x00\x00\x00\x00\x00\x07\x00\xad\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00"# +happyGotoOffsets = HappyA# "\x75\x00\x2f\x02\x00\x00\x00\x00\x7c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x01\xad\x01\xac\x01\xa7\x01\x9c\x01\x06\x00\x9a\x01\x94\x01\x8c\x01\x87\x01\x86\x01\x85\x01\x00\x00\xdf\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x80\x01\x60\x01\x00\x00\xf2\x00\x6b\x01\x63\x01\x1c\x02\x62\x01\x34\x01\x81\x01\x7d\x01\xab\x00\x09\x02\x5d\x01\x00\x00\x01\x00\x57\x01\x04\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x02\x00\x00\x00\x00\x00\x00\x00\x00\x41\x01\x40\x01\xfe\x01\x2b\x01\x3a\x01\x36\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x74\x01\x33\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\xeb\x01\xe0\x01\x00\x00\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x48\x01\x9c\x00\x6a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\xcd\x01\x2f\x01\x19\x01\x00\x00\x10\x01\xdf\x00\xee\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\xc2\x01\x00\x00\xaf\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x31\x01\x0c\x01\xf1\x00\x14\x01\x00\x00\x00\x00\x00\x00\xeb\x00\x6f\x00\xea\x00\x00\x00\xa0\x00\x00\x00\x00\x00\xcf\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x28\x01\x5a\x01\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x7a\x01\x08\x00\xb9\x00\xb4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x7b\x00\x00\x00\x00\x00\x1b\x00\x00\x00\xaf\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\xac\x00\x80\x00\x00\x00\x71\x01\x69\x01\x61\x00\x71\x01\x00\x00\x00\x00\x00\x00\x08\x01\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x01\x00\x00\x00\x00\xe1\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x00\x00\x51\x00\x91\x01\x0e\x00\x00\x00\x00\x00\x77\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x6b\x00\x00\x00\xff\x00\x00\x00\x2a\x01\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x89\x01\x00\x00\x15\x00\x00\x00\x00\x00\x0b\x00\xde\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00"# happyDefActions :: HappyAddr -happyDefActions = HappyA# "\xf4\xff\x00\x00\xfe\xff\x00\x00\xfa\xff\x79\xff\x78\xff\x00\x00\xf3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xff\x00\x00\xf8\xff\xf1\xff\x00\x00\x79\xff\x77\xff\x00\x00\xef\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xf2\xff\x00\x00\x79\xff\xf4\xff\xfb\xff\x00\x00\x9c\xff\x00\x00\xf5\xff\x9a\xff\xf0\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe3\xff\x00\x00\xf9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\xff\x00\x00\xe4\xff\x00\x00\xee\xff\x00\x00\xd1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x98\xff\x00\x00\x00\x00\xc6\xff\xc5\xff\xca\xff\xdc\xff\xeb\xff\xe0\xff\xc4\xff\xdb\xff\xcc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xda\xff\xfd\xff\xfc\xff\x95\xff\x97\xff\xea\xff\xc0\xff\x00\x00\x8b\xff\x00\x00\x00\x00\xbf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xff\xe6\xff\xd1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\xff\x00\x00\xa6\xff\x8a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x98\xff\xe5\xff\xc7\xff\xc8\xff\x00\x00\x00\x00\x00\x00\x00\x00\xce\xff\xe1\xff\x00\x00\x00\x00\xe2\xff\x00\x00\x00\x00\xdd\xff\x00\x00\xd9\xff\x00\x00\xc9\xff\x94\xff\x96\xff\x00\x00\xab\xff\xb7\xff\xbb\xff\xae\xff\xac\xff\xe9\xff\xb6\xff\xbc\xff\x91\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\xff\xc2\xff\x00\x00\x8b\xff\x00\x00\x00\x00\x8e\xff\xec\xff\xc3\xff\x93\xff\xcf\xff\xed\xff\x00\x00\x8d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\xbd\xff\x85\xff\x00\x00\xb9\xff\x85\xff\x00\x00\xb5\xff\x83\xff\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\xff\xd5\xff\xd4\xff\xd3\xff\xcd\xff\x00\x00\x00\x00\xd2\xff\xcb\xff\xce\xff\xd7\xff\x00\x00\x00\x00\xa4\xff\xb3\xff\xb0\xff\xb8\xff\x00\x00\x91\xff\x00\x00\xb4\xff\x00\x00\x7b\xff\x85\xff\x00\x00\xc1\xff\xad\xff\xe8\xff\x00\x00\x8e\xff\x92\xff\x8c\xff\x00\x00\x84\xff\xaf\xff\x00\x00\x87\xff\x00\x00\x00\x00\xba\xff\x82\xff\x81\xff\x8f\xff\xa9\xff\x00\x00\x00\x00\x00\x00\xd6\xff\xdf\xff\xa3\xff\x80\xff\x00\x00\x00\x00\xa1\xff\x9e\xff\x7a\xff\x7e\xff\x00\x00\xa0\xff\x00\x00\xb2\xff\x7b\xff\xb1\xff\x00\x00\xe7\xff\x86\xff\xa8\xff\x7b\xff\x00\x00\x7d\xff\x00\x00\x00\x00\x83\xff\x81\xff\x7f\xff\xa7\xff\xaa\xff\x9f\xff\x7e\xff\x00\x00\x00\x00\xa2\xff\x9d\xff\x7c\xff"# +happyDefActions = HappyA# "\xee\xff\x00\x00\x00\x00\xfd\xff\xdd\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\x73\xff\x72\xff\x00\x00\xed\xff\x00\x00\x00\x00\x00\x00\xf0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\xf5\xff\xf6\xff\xeb\xff\x00\x00\xde\xff\x00\x00\xe9\xff\x00\x00\xcb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\xff\x00\x00\x00\x00\x00\x00\xeb\xff\x00\x00\x73\xff\x71\xff\x00\x00\xe9\xff\x00\x00\x00\x00\xc0\xff\xbf\xff\xc4\xff\xd6\xff\xe5\xff\xda\xff\xbe\xff\xd5\xff\xc6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xff\xd4\xff\xfc\xff\xfb\xff\x8f\xff\x91\xff\xe4\xff\xba\xff\x00\x00\x85\xff\x00\x00\x00\x00\xb9\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\xf1\xff\x00\x00\x00\x00\xca\xff\xec\xff\x00\x00\x73\xff\xe0\xff\x00\x00\xf7\xff\xcb\xff\x00\x00\x00\x00\x00\x00\xf8\xff\x00\x00\x00\x00\xb8\xff\x00\x00\xa0\xff\x84\xff\x00\x00\x00\x00\x00\x00\x00\x00\x92\xff\xdf\xff\xc1\xff\xc2\xff\x00\x00\x00\x00\x00\x00\x00\x00\xc8\xff\xdb\xff\x00\x00\x00\x00\x00\x00\x00\x00\xee\xff\xfa\xff\x96\xff\xef\xff\xdc\xff\x00\x00\x00\x00\xd7\xff\x00\x00\xd3\xff\x00\x00\xc3\xff\x8e\xff\x90\xff\x00\x00\xa5\xff\xb1\xff\xb5\xff\xa8\xff\xa6\xff\xe3\xff\xb0\xff\xb6\xff\x8b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\xff\xbc\xff\x00\x00\x85\xff\x00\x00\x00\x00\x88\xff\xe6\xff\xbd\xff\x8d\xff\xc9\xff\xea\xff\xe7\xff\x00\x00\x87\xff\x00\x00\x00\x00\x00\x00\x00\x00\x83\xff\xb7\xff\x7f\xff\x00\x00\xb3\xff\x7f\xff\x00\x00\xaf\xff\x7d\xff\x8a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xcf\xff\xce\xff\xcd\xff\xc7\xff\x00\x00\x00\x00\xcc\xff\xc5\xff\x94\xff\x00\x00\x00\x00\xc8\xff\xd1\xff\x00\x00\x00\x00\x9e\xff\xad\xff\xaa\xff\xb2\xff\x00\x00\x8b\xff\x00\x00\xae\xff\x00\x00\x75\xff\x7f\xff\x00\x00\xbb\xff\xa7\xff\xe2\xff\x00\x00\x88\xff\x8c\xff\x86\xff\x00\x00\x7e\xff\xa9\xff\x00\x00\x81\xff\x00\x00\x00\x00\xb4\xff\x7c\xff\x7b\xff\x89\xff\xa3\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\x00\x00\x95\xff\x00\x00\x93\xff\xd0\xff\xd9\xff\x9d\xff\x7a\xff\x00\x00\x00\x00\x9b\xff\x98\xff\x74\xff\x78\xff\x00\x00\x9a\xff\x00\x00\xac\xff\x75\xff\xab\xff\x00\x00\xe1\xff\x80\xff\xa2\xff\x75\xff\x00\x00\x77\xff\x00\x00\x00\x00\x7d\xff\x7b\xff\x79\xff\xa1\xff\xa4\xff\x99\xff\x78\xff\x00\x00\x00\x00\x9c\xff\x97\xff\x76\xff"# happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x11\x00\x00\x00\x01\x00\x02\x00\x00\x00\x03\x00\x02\x00\x09\x00\x01\x00\x03\x00\x08\x00\x03\x00\x03\x00\x01\x00\x0c\x00\x06\x00\x0a\x00\x0f\x00\x0c\x00\x11\x00\x13\x00\x0f\x00\x1a\x00\x11\x00\x12\x00\x07\x00\x1f\x00\x00\x00\x15\x00\x22\x00\x22\x00\x22\x00\x31\x00\x22\x00\x25\x00\x1d\x00\x25\x00\x00\x00\x2b\x00\x21\x00\x24\x00\x2d\x00\x2c\x00\x34\x00\x34\x00\x34\x00\x34\x00\x32\x00\x2e\x00\x32\x00\x30\x00\x31\x00\x32\x00\x33\x00\x03\x00\x31\x00\x32\x00\x33\x00\x32\x00\x08\x00\x09\x00\x09\x00\x23\x00\x0c\x00\x03\x00\x04\x00\x0f\x00\x31\x00\x11\x00\x08\x00\x03\x00\x2c\x00\x23\x00\x0c\x00\x30\x00\x08\x00\x0f\x00\x03\x00\x11\x00\x0c\x00\x03\x00\x2c\x00\x0f\x00\x10\x00\x11\x00\x08\x00\x0c\x00\x0d\x00\x0e\x00\x0c\x00\x03\x00\x27\x00\x0f\x00\x03\x00\x11\x00\x00\x00\x03\x00\x03\x00\x08\x00\x0c\x00\x31\x00\x32\x00\x33\x00\x16\x00\x00\x00\x0c\x00\x0c\x00\x0e\x00\x0e\x00\x00\x00\x31\x00\x32\x00\x33\x00\x13\x00\x1b\x00\x1c\x00\x31\x00\x32\x00\x33\x00\x04\x00\x0b\x00\x1a\x00\x00\x00\x31\x00\x06\x00\x33\x00\x31\x00\x32\x00\x33\x00\x22\x00\x0c\x00\x32\x00\x0e\x00\x0d\x00\x33\x00\x1f\x00\x31\x00\x00\x00\x22\x00\x01\x00\x2d\x00\x15\x00\x31\x00\x31\x00\x33\x00\x33\x00\x1f\x00\x2b\x00\x0b\x00\x28\x00\x23\x00\x16\x00\x01\x00\x26\x00\x27\x00\x16\x00\x22\x00\x2a\x00\x2b\x00\x0c\x00\x0d\x00\x0e\x00\x2f\x00\x00\x00\x31\x00\x02\x00\x02\x00\x31\x00\x32\x00\x33\x00\x0c\x00\x00\x00\x15\x00\x0f\x00\x2f\x00\x11\x00\x12\x00\x28\x00\x00\x00\x32\x00\x02\x00\x20\x00\x00\x00\x32\x00\x0d\x00\x04\x00\x05\x00\x1d\x00\x00\x00\x01\x00\x02\x00\x21\x00\x00\x00\x01\x00\x02\x00\x2e\x00\x31\x00\x32\x00\x33\x00\x24\x00\x33\x00\x0d\x00\x14\x00\x17\x00\x18\x00\x0d\x00\x18\x00\x31\x00\x32\x00\x33\x00\x21\x00\x00\x00\x01\x00\x02\x00\x24\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x23\x00\x0d\x00\x30\x00\x31\x00\x23\x00\x21\x00\x00\x00\x01\x00\x02\x00\x00\x00\x12\x00\x01\x00\x15\x00\x15\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x0d\x00\x30\x00\x31\x00\x0d\x00\x23\x00\x00\x00\x01\x00\x02\x00\x0d\x00\x00\x00\x02\x00\x30\x00\x02\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x0d\x00\x0a\x00\x19\x00\x05\x00\x23\x00\x00\x00\x01\x00\x02\x00\x0d\x00\x0b\x00\x2f\x00\x2f\x00\x2a\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x0d\x00\x00\x00\x19\x00\x00\x00\x23\x00\x00\x00\x01\x00\x02\x00\x0d\x00\x02\x00\x02\x00\x29\x00\x02\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x0d\x00\x00\x00\x19\x00\x00\x00\x23\x00\x00\x00\x01\x00\x02\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x0d\x00\x16\x00\x19\x00\x14\x00\x23\x00\x0d\x00\x0d\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x23\x00\x1e\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x01\x00\x02\x00\x0d\x00\x1e\x00\x0c\x00\x20\x00\x00\x00\x00\x00\x1b\x00\x0d\x00\x0d\x00\x1e\x00\x0d\x00\x00\x00\x19\x00\x0b\x00\x23\x00\x00\x00\x2d\x00\x0d\x00\x2f\x00\x19\x00\x19\x00\x00\x00\x01\x00\x02\x00\x1b\x00\x17\x00\x18\x00\x1e\x00\x20\x00\x00\x00\x00\x00\x00\x00\x23\x00\x00\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x2e\x00\x0d\x00\x17\x00\x00\x00\x0d\x00\x33\x00\x26\x00\x06\x00\x00\x00\x00\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x08\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x09\x00\x01\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x04\x00\x02\x00\x17\x00\x15\x00\x04\x00\x31\x00\x04\x00\x01\x00\x33\x00\x04\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x01\x00\x15\x00\x17\x00\x0d\x00\x15\x00\x14\x00\x31\x00\x04\x00\x06\x00\x17\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x04\x00\x02\x00\x17\x00\x01\x00\x31\x00\x0d\x00\x06\x00\x33\x00\x1a\x00\x03\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x0b\x00\x15\x00\x17\x00\x14\x00\x31\x00\x31\x00\x01\x00\x31\x00\x04\x00\x06\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x10\x00\x0d\x00\x17\x00\x31\x00\x33\x00\x04\x00\x01\x00\x05\x00\x13\x00\x0a\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x02\x00\x01\x00\x17\x00\x31\x00\x09\x00\x02\x00\x05\x00\x02\x00\x02\x00\x33\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x01\x00\x02\x00\x02\x00\x19\x00\x17\x00\x31\x00\x0b\x00\x00\x00\x01\x00\x02\x00\x33\x00\x31\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x25\x00\x08\x00\x05\x00\x0d\x00\x05\x00\x17\x00\x10\x00\x11\x00\x02\x00\x05\x00\x02\x00\x02\x00\x01\x00\x17\x00\x21\x00\x31\x00\x02\x00\x01\x00\x31\x00\x22\x00\x31\x00\x25\x00\x03\x00\x31\x00\x06\x00\x31\x00\x01\x00\x07\x00\x29\x00\x31\x00\x02\x00\x28\x00\x05\x00\x1a\x00\x28\x00\x31\x00\x24\x00\x31\x00\xff\xff\xff\xff\xff\xff\x31\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# +happyCheck = HappyA# "\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x08\x00\x08\x00\x00\x00\x00\x00\x03\x00\x00\x00\x01\x00\x02\x00\x16\x00\x03\x00\x03\x00\x0d\x00\x01\x00\x01\x00\x05\x00\x08\x00\x0a\x00\x03\x00\x0c\x00\x15\x00\x0b\x00\x0f\x00\x08\x00\x11\x00\x12\x00\x14\x00\x0c\x00\x07\x00\x0a\x00\x0f\x00\x31\x00\x11\x00\x15\x00\x03\x00\x23\x00\x1d\x00\x32\x00\x23\x00\x23\x00\x21\x00\x26\x00\x26\x00\x0c\x00\x0d\x00\x0e\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x32\x00\x34\x00\x33\x00\x33\x00\x31\x00\x32\x00\x33\x00\x28\x00\x31\x00\x2e\x00\x03\x00\x30\x00\x31\x00\x32\x00\x33\x00\x08\x00\x09\x00\x01\x00\x31\x00\x0c\x00\x03\x00\x04\x00\x0f\x00\x02\x00\x11\x00\x08\x00\x03\x00\x09\x00\x31\x00\x0c\x00\x33\x00\x08\x00\x0f\x00\x03\x00\x11\x00\x0c\x00\x03\x00\x16\x00\x0f\x00\x10\x00\x11\x00\x08\x00\x0c\x00\x03\x00\x0e\x00\x0c\x00\x03\x00\x00\x00\x0f\x00\x13\x00\x11\x00\x00\x00\x0c\x00\x00\x00\x0e\x00\x0c\x00\x31\x00\x32\x00\x33\x00\x00\x00\x03\x00\x0e\x00\x2c\x00\x00\x00\x07\x00\x32\x00\x31\x00\x32\x00\x33\x00\x01\x00\x1b\x00\x1c\x00\x31\x00\x32\x00\x33\x00\x04\x00\x16\x00\x0e\x00\x1b\x00\x31\x00\x1b\x00\x33\x00\x31\x00\x32\x00\x33\x00\x30\x00\x23\x00\x06\x00\x23\x00\x31\x00\x04\x00\x33\x00\x31\x00\x0c\x00\x16\x00\x0e\x00\x00\x00\x2e\x00\x00\x00\x2e\x00\x00\x00\x1e\x00\x1f\x00\x20\x00\x32\x00\x22\x00\x23\x00\x24\x00\x0c\x00\x26\x00\x27\x00\x00\x00\x00\x00\x2a\x00\x2b\x00\x00\x00\x2d\x00\x1f\x00\x2f\x00\x00\x00\x31\x00\x23\x00\x02\x00\x0c\x00\x26\x00\x27\x00\x0b\x00\x02\x00\x2a\x00\x2b\x00\x31\x00\x32\x00\x33\x00\x2f\x00\x24\x00\x31\x00\x24\x00\x29\x00\x31\x00\x01\x00\x0c\x00\x0d\x00\x0e\x00\x2d\x00\x20\x00\x2d\x00\x00\x00\x23\x00\x02\x00\x30\x00\x13\x00\x20\x00\x29\x00\x16\x00\x23\x00\x0c\x00\x2c\x00\x00\x00\x0f\x00\x15\x00\x11\x00\x12\x00\x00\x00\x2c\x00\x02\x00\x00\x00\x00\x00\x02\x00\x05\x00\x06\x00\x02\x00\x0e\x00\x1d\x00\x05\x00\x00\x00\x00\x00\x21\x00\x31\x00\x32\x00\x33\x00\x30\x00\x00\x00\x00\x00\x25\x00\x00\x00\x01\x00\x02\x00\x15\x00\x0e\x00\x0e\x00\x2b\x00\x19\x00\x31\x00\x32\x00\x33\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x25\x00\x1a\x00\x1a\x00\x25\x00\x15\x00\x00\x00\x01\x00\x02\x00\x19\x00\x00\x00\x0e\x00\x17\x00\x18\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x27\x00\x0e\x00\x07\x00\x24\x00\x00\x00\x0e\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x24\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x00\x00\x24\x00\x0e\x00\x1a\x00\x00\x00\x02\x00\x00\x00\x01\x00\x02\x00\x00\x00\x02\x00\x0e\x00\x2a\x00\x02\x00\x0e\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x0e\x00\x00\x00\x09\x00\x0e\x00\x24\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x21\x00\x24\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x0b\x00\x24\x00\x0e\x00\x00\x00\x17\x00\x2f\x00\x00\x00\x01\x00\x02\x00\x00\x00\x34\x00\x0e\x00\x17\x00\x18\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x0e\x00\x09\x00\x00\x00\x00\x00\x24\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x00\x00\x24\x00\x1c\x00\x1d\x00\x0e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x00\x00\x24\x00\x0e\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x0d\x00\x21\x00\x0e\x00\x00\x00\x1c\x00\x1a\x00\x0e\x00\x1f\x00\x00\x00\x01\x00\x02\x00\x00\x00\x24\x00\x1c\x00\x1a\x00\x2f\x00\x1f\x00\x00\x00\x1a\x00\x00\x00\x34\x00\x24\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x00\x00\x1e\x00\x18\x00\x20\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x2d\x00\x04\x00\x2f\x00\x31\x00\x32\x00\x18\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x32\x00\x09\x00\x18\x00\x22\x00\x01\x00\x15\x00\x02\x00\x31\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x04\x00\x04\x00\x31\x00\x32\x00\x01\x00\x18\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x02\x00\x31\x00\x18\x00\x01\x00\x04\x00\x15\x00\x33\x00\x01\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x15\x00\x31\x00\x04\x00\x14\x00\x01\x00\x18\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x17\x00\x06\x00\x18\x00\x0d\x00\x31\x00\x22\x00\x04\x00\x33\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x02\x00\x01\x00\x18\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x0e\x00\x0d\x00\x18\x00\x11\x00\x12\x00\x06\x00\x1a\x00\x31\x00\x03\x00\x01\x00\x18\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x31\x00\x0b\x00\x15\x00\x04\x00\x18\x00\x06\x00\x14\x00\x03\x00\x31\x00\x0a\x00\x0b\x00\x04\x00\x06\x00\x0d\x00\x10\x00\x31\x00\x33\x00\x04\x00\x01\x00\x05\x00\x13\x00\x0a\x00\x02\x00\x31\x00\x25\x00\x31\x00\x03\x00\x01\x00\x09\x00\x05\x00\x02\x00\x01\x00\x31\x00\x02\x00\x02\x00\x33\x00\x02\x00\x19\x00\x0b\x00\x06\x00\x33\x00\x01\x00\x31\x00\x29\x00\x05\x00\x31\x00\x29\x00\x25\x00\x07\x00\x28\x00\x08\x00\x02\x00\x31\x00\x05\x00\x02\x00\x28\x00\x05\x00\x02\x00\x05\x00\x02\x00\x01\x00\x28\x00\x1a\x00\x01\x00\xff\xff\x31\x00\x02\x00\x31\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x35\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# happyTable :: HappyAddr -happyTable = HappyA# "\x00\x00\x06\x00\x06\x00\x06\x00\x06\x00\x76\x00\x76\x00\x76\x00\x17\x00\x76\x00\x7b\x00\xc6\x00\xc7\x00\xc8\x00\xfa\x00\x9c\x00\xfb\x00\xbc\x00\x05\x01\x55\x00\x9d\x00\xef\x00\x03\x00\xed\x00\x9e\x00\x04\x00\x56\x00\x9f\x00\x57\x00\xa0\x00\xc9\x00\x58\x00\x77\x00\x59\x00\x5a\x00\x79\xff\xbd\x00\xae\x00\xb3\x00\xbe\x00\x78\x00\x09\x01\x03\x00\x09\x01\x0a\x01\x5b\x00\x0a\x01\xae\x00\xef\x00\x5c\x00\xfc\x00\xb4\x00\xbd\x00\x18\x00\x22\x00\x15\x00\x07\x00\x18\x01\xa1\x00\x0b\x01\xa2\x00\x03\x00\x5d\x00\x5e\x00\x9c\x00\x03\x00\x5d\x00\x5e\x00\x5d\x00\x9d\x00\x04\x01\x28\x00\xaf\x00\x9e\x00\x9c\x00\xe8\x00\x9f\x00\x03\x00\xa0\x00\x9d\x00\x9c\x00\xe4\x00\xaf\x00\x9e\x00\x10\x01\x9d\x00\x9f\x00\xfe\x00\xa0\x00\x9e\x00\x9c\x00\xb0\x00\x9f\x00\xed\x00\xa0\x00\x9d\x00\xff\x00\x17\x01\x00\x01\x9e\x00\x64\x00\x29\x00\x9f\x00\xdc\x00\xa0\x00\x76\x00\xfe\x00\xfe\x00\xdd\x00\x65\x00\x03\x00\x5d\x00\x5e\x00\x83\xff\x76\x00\xff\x00\xff\x00\x00\x01\x00\x01\x5e\x00\x03\x00\x5d\x00\x5e\x00\x01\x01\x66\x00\x67\x00\x03\x00\x5d\x00\x5e\x00\x2f\x00\x5f\x00\x77\x00\x76\x00\x03\x00\xcb\x00\x5e\x00\x03\x00\x5d\x00\x5e\x00\x78\x00\xcc\x00\x83\xff\xcd\x00\xda\x00\x15\x01\xbd\x00\x03\x00\x5e\x00\xbe\x00\xed\x00\x79\x00\xb3\x00\x03\x00\x03\x00\x5e\x00\x5e\x00\x30\x00\xbf\x00\x5f\x00\x91\x00\x31\x00\x0e\x01\xb2\x00\x32\x00\x33\x00\x83\xff\xd3\x00\x34\x00\x35\x00\xcc\x00\xf5\x00\xcd\x00\x36\x00\xfa\x00\x03\x00\xfb\x00\xf6\x00\x03\x00\x5d\x00\x5e\x00\x87\x00\x4b\x00\xb3\x00\x58\x00\xe8\x00\x59\x00\x5a\x00\x60\x00\xfa\x00\x5d\x00\xfb\x00\xe9\x00\x6a\x00\x83\xff\x08\x01\x08\x00\x09\x00\x5b\x00\x92\x00\x93\x00\x94\x00\x5c\x00\x92\x00\x93\x00\x94\x00\x06\x01\x03\x00\x5d\x00\x5e\x00\x17\x01\xeb\x00\x95\x00\xac\x00\xc3\x00\xc4\x00\x95\x00\x6c\x00\x03\x00\x5d\x00\x5e\x00\xf7\x00\x92\x00\x93\x00\x94\x00\xfc\x00\x96\x00\x97\x00\x05\x01\x99\x00\x96\x00\x97\x00\x07\x01\x99\x00\x9a\x00\x95\x00\xf8\x00\x0f\x01\x9a\x00\xf7\x00\x92\x00\x93\x00\x94\x00\x4b\x00\x89\x00\xed\x00\xf3\x00\x8a\x00\x4b\x00\x96\x00\x97\x00\xe5\x00\x99\x00\x95\x00\xf8\x00\xf9\x00\xce\x00\x9a\x00\x92\x00\x93\x00\x94\x00\x61\x00\x2c\x00\xd1\x00\xd8\x00\xd2\x00\x4b\x00\x96\x00\x97\x00\xf0\x00\x99\x00\x95\x00\x2d\x00\xb3\x00\x8f\x00\x9a\x00\x92\x00\x93\x00\x94\x00\x61\x00\x88\x00\xda\x00\xdd\x00\xad\x00\x4b\x00\x96\x00\x97\x00\xe0\x00\x99\x00\x95\x00\xb8\x00\xb5\x00\x88\x00\x9a\x00\x92\x00\x93\x00\x94\x00\x61\x00\xa2\x00\x74\x00\x7d\x00\x7e\x00\x4b\x00\x96\x00\x97\x00\xba\x00\x99\x00\x95\x00\x6a\x00\xb7\x00\x7f\x00\x9a\x00\x92\x00\x93\x00\x94\x00\x61\x00\x83\x00\x4b\x00\x92\x00\x93\x00\x94\x00\x96\x00\x97\x00\x98\x00\x99\x00\x95\x00\x84\x00\x90\x00\x6b\x00\x9a\x00\xe3\x00\x95\x00\x6c\x00\x6d\x00\x42\x00\x37\x00\x92\x00\x93\x00\x94\x00\x96\x00\x97\x00\xa7\x00\x99\x00\x38\x00\x4b\x00\x96\x00\xdf\x00\x9a\x00\x99\x00\x95\x00\x39\x00\x4b\x00\x4b\x00\x9a\x00\x92\x00\x93\x00\x94\x00\x61\x00\x0b\x00\x3f\x00\x0c\x00\x4b\x00\x3a\x00\xe6\x00\x61\x00\x61\x00\x99\x00\x95\x00\x3b\x00\x75\x00\x88\x00\x9a\x00\x3c\x00\x0d\x00\xb9\x00\x0e\x00\x62\x00\x67\x00\x4b\x00\x4c\x00\x4d\x00\xd4\x00\xc3\x00\xc4\x00\x99\x00\xe9\x00\x3d\x00\x4b\x00\x2b\x00\x9a\x00\x4b\x00\x4e\x00\x4f\x00\xf5\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\xea\x00\x80\x00\x53\x00\x25\x00\x68\x00\xeb\x00\x26\x00\x21\x00\x1b\x00\x1c\x00\x4e\x00\x4f\x00\xcf\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\x1e\x00\x16\x00\x53\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x5d\x00\x12\x01\x14\x01\x4e\x00\x4f\x00\xc4\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\x13\x01\x15\x01\x53\x00\xb3\x00\x88\xff\x03\x00\x0d\x01\x0f\x01\x5e\x00\x02\x01\x4e\x00\x4f\x00\xc5\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\x03\x01\xb3\x00\x53\x00\xd1\x00\xb3\x00\xc1\x00\x03\x00\x88\xff\xf3\x00\xf2\x00\x4e\x00\x4f\x00\x82\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\xd6\x00\xd7\x00\x53\x00\xd8\x00\x03\x00\xdf\x00\xe2\x00\x5e\x00\xe3\x00\xb7\x00\x4e\x00\x4f\x00\xa9\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\xc2\x00\xb3\x00\x53\x00\xc1\x00\x03\x00\x03\x00\xce\x00\x03\x00\x8c\x00\x8d\x00\x4e\x00\x4f\x00\xaa\x00\x51\x00\x52\x00\x81\x00\x4c\x00\x4d\x00\x90\x00\x8e\x00\x53\x00\x03\x00\x5e\x00\xa4\x00\xa6\x00\xa5\x00\xa7\x00\xa9\x00\x4e\x00\x4f\x00\x82\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\xac\x00\x6f\x00\x53\x00\x03\x00\x70\x00\x72\x00\x71\x00\x73\x00\x74\x00\x5e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x4b\x00\x4c\x00\x4d\x00\x7c\x00\x7d\x00\x53\x00\x03\x00\x88\x00\x4b\x00\x4c\x00\x4d\x00\x5e\x00\x03\x00\x4e\x00\x4f\x00\x69\x00\x51\x00\x52\x00\x44\x00\x45\x00\x46\x00\x4e\x00\x47\x00\x53\x00\x85\x00\x52\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x3f\x00\x53\x00\x41\x00\x03\x00\x42\x00\x37\x00\x03\x00\x2b\x00\x03\x00\x28\x00\x24\x00\x03\x00\x25\x00\x03\x00\x21\x00\x1e\x00\x20\x00\x03\x00\x13\x00\x1a\x00\x1b\x00\x15\x00\x14\x00\x03\x00\x06\x00\x03\x00\x00\x00\x00\x00\x00\x00\x03\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# +happyTable = HappyA# "\x00\x00\x19\x00\x19\x00\x19\x00\x19\x00\x19\x00\x19\x00\x7e\x00\x79\x00\x43\x00\x30\x00\x79\x00\x79\x00\xfc\x00\xd0\x00\xd1\x00\xd2\x00\x7d\xff\x4f\x00\xe9\x00\xe7\x00\x18\x01\xfa\x00\x98\x00\xea\x00\x50\x00\xa5\x00\x51\x00\xbd\x00\x8b\x00\x52\x00\xa6\x00\x53\x00\x54\x00\xd3\x00\xa7\x00\x73\xff\xd9\x00\xa8\x00\x04\x00\xa9\x00\xbd\x00\x11\x01\xe0\x00\x55\x00\x7d\xff\x1c\x01\x1c\x01\x56\x00\x1d\x01\x1d\x01\x12\x01\x2a\x01\x13\x01\x31\x00\x31\x00\x6e\x00\x41\x00\x1a\x00\x24\x00\x57\x00\x28\x01\x2b\x01\x1e\x01\x04\x00\x57\x00\x58\x00\xda\x00\x23\x01\xaa\x00\xa5\x00\xab\x00\x04\x00\x57\x00\x58\x00\xa6\x00\x17\x01\xfa\x00\x04\x00\xa7\x00\xa5\x00\xf5\x00\xa8\x00\x09\x01\xa9\x00\xa6\x00\xa5\x00\xc6\x00\x04\x00\xa7\x00\x58\x00\xa6\x00\xa8\x00\x11\x01\xa9\x00\xa7\x00\xa5\x00\x21\x01\xa8\x00\xfa\x00\xa9\x00\xa6\x00\x12\x01\x11\x01\x13\x01\xa7\x00\x5e\x00\x45\x00\xa8\x00\x14\x01\xa9\x00\x79\x00\x12\x01\x79\x00\x13\x01\x5f\x00\x04\x00\x57\x00\x58\x00\x05\x01\x16\x00\x1b\x01\xc7\x00\x45\x00\x17\x00\x57\x00\x04\x00\x57\x00\x58\x00\xfa\x00\x60\x00\x61\x00\x04\x00\x57\x00\x58\x00\x0a\x00\x7d\xff\xdb\x00\x7a\x00\x04\x00\x7a\x00\x58\x00\x04\x00\x57\x00\x58\x00\xf5\x00\x7b\x00\xd5\x00\x7b\x00\x04\x00\x03\x01\x58\x00\x04\x00\xd6\x00\x00\x01\xd7\x00\x58\x00\xbe\x00\xb8\x00\x7c\x00\xb8\x00\x0b\x00\x0c\x00\x0d\x00\x7d\xff\x0e\x00\x0f\x00\x10\x00\x59\x00\x11\x00\x12\x00\x58\x00\x79\x00\x13\x00\x14\x00\x04\x00\x15\x00\x0c\x00\x16\x00\x79\x00\x04\x00\x0f\x00\xde\x00\x59\x00\x11\x00\x12\x00\x01\x01\xdf\x00\x13\x00\x14\x00\x04\x00\x57\x00\x58\x00\x04\x01\xb9\x00\x04\x00\xb9\x00\x9a\x00\xe5\x00\xbc\x00\xd6\x00\x08\x01\xd7\x00\xf1\x00\xc7\x00\xba\x00\x0d\x01\xc8\x00\x0e\x01\xe7\x00\x92\x00\xc7\x00\x5a\x00\x93\x00\xc8\x00\x8a\x00\xfc\x00\x45\x00\x52\x00\xbd\x00\x53\x00\x54\x00\x0d\x01\xc9\x00\x0e\x01\x0d\x01\x67\x00\x0e\x01\x1b\x00\x1c\x00\x3c\x00\xf0\x00\x55\x00\x3d\x00\x45\x00\x45\x00\x56\x00\x04\x00\x57\x00\x58\x00\xea\x00\xc2\x00\x67\x00\x0f\x01\x9b\x00\x9c\x00\x9d\x00\xb5\x00\x5b\x00\x5b\x00\xb7\x00\x69\x00\x04\x00\x57\x00\x58\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x2a\x01\xbd\x00\xbf\x00\x0f\x01\x68\x00\x9b\x00\x9c\x00\x9d\x00\x69\x00\x45\x00\x9e\x00\xcd\x00\xce\x00\x9f\x00\xa0\x00\x18\x01\xa2\x00\x45\x00\xd8\x00\x9e\x00\x8e\x00\xa3\x00\x90\x00\xc3\x00\x9f\x00\xa0\x00\x1a\x01\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x5b\x00\xa3\x00\x9f\x00\xa0\x00\xf2\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x45\x00\xa3\x00\x9e\x00\xc1\x00\x91\x00\xab\x00\x9b\x00\x9c\x00\x9d\x00\x45\x00\x77\x00\x9e\x00\x80\x00\x81\x00\x83\x00\x82\x00\x9f\x00\xa0\x00\xfd\x00\xa2\x00\x9e\x00\x86\x00\x8c\x00\x62\x00\xa3\x00\x9f\x00\xa0\x00\xed\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\xf6\x00\xa3\x00\x9f\x00\xa0\x00\xc4\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x8b\x00\xa3\x00\x9e\x00\x42\x00\x87\x00\x19\x01\x9b\x00\x9c\x00\x9d\x00\x44\x00\xf8\x00\x9e\x00\xcd\x00\xce\x00\x63\x00\x65\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\x9e\x00\x6b\x00\x45\x00\x66\x00\xa3\x00\x9f\x00\xa0\x00\xb0\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x45\x00\xa3\x00\x9f\x00\xec\x00\x5b\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x45\x00\xa3\x00\x9e\x00\x6d\x00\x45\x00\x5b\x00\x3d\x00\x99\x00\x1e\x00\x1f\x00\x20\x00\x9e\x00\x2d\x00\xf6\x00\x5b\x00\x21\x00\xf3\x00\x78\x00\x5b\x00\xa2\x00\x45\x00\x46\x00\x47\x00\x22\x00\xa3\x00\xe1\x00\x5c\x00\xf7\x00\xa2\x00\x23\x00\x61\x00\x25\x00\xf8\x00\xa3\x00\x48\x00\x49\x00\x08\x01\x4b\x00\x4c\x00\x45\x00\x46\x00\x47\x00\x26\x00\x0b\x00\x4d\x00\x0d\x00\x0a\x01\x27\x00\x28\x00\x29\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xdc\x00\x4b\x00\x4c\x00\x15\x00\x26\x01\x1e\x00\x0b\x01\x22\x01\x4d\x00\x48\x00\x49\x00\xce\x00\x4b\x00\x4c\x00\x45\x00\x46\x00\x47\x00\x57\x00\x25\x01\x4d\x00\x0a\x01\x27\x01\xbd\x00\x28\x01\x04\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xcf\x00\x4b\x00\x4c\x00\x82\xff\x20\x01\x0b\x01\x0c\x01\x22\x01\x4d\x00\x48\x00\x49\x00\x85\x00\x4b\x00\x4c\x00\x45\x00\x46\x00\x47\x00\x3c\x00\x04\x00\x4d\x00\x07\x01\x15\x01\xbd\x00\x58\x00\x16\x01\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xb2\x00\x4b\x00\x4c\x00\xbd\x00\x04\x00\x82\xff\xcb\x00\x05\x01\x4d\x00\x48\x00\x49\x00\xb3\x00\x4b\x00\x4c\x00\x84\x00\x46\x00\x47\x00\xff\x00\x00\x01\x4d\x00\xde\x00\x04\x00\x0e\x00\xe3\x00\x58\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x85\x00\x4b\x00\x4c\x00\x45\x00\x46\x00\x47\x00\xe4\x00\xe5\x00\x4d\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x45\x00\x46\x00\x47\x00\x48\x00\xec\x00\x4d\x00\x88\x00\x4c\x00\xef\x00\xf0\x00\x04\x00\xc1\x00\xd8\x00\x4d\x00\x48\x00\x49\x00\x64\x00\x4b\x00\x4c\x00\x04\x00\x04\x00\xcc\x00\xbd\x00\x05\x00\x4d\x00\x06\x00\xcb\x00\x90\x00\x04\x00\x07\x00\x08\x00\x95\x00\x96\x00\x97\x00\x99\x00\x04\x00\x58\x00\xad\x00\xaf\x00\xae\x00\xb0\x00\xb2\x00\xb5\x00\x04\x00\xb7\x00\x04\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x04\x00\x76\x00\x77\x00\x58\x00\x7f\x00\x80\x00\x8b\x00\x8c\x00\x58\x00\x8e\x00\x04\x00\x6d\x00\x3d\x00\x04\x00\x6d\x00\x30\x00\x6b\x00\x34\x00\x33\x00\x35\x00\x04\x00\x36\x00\x39\x00\x37\x00\x38\x00\x3b\x00\x3a\x00\x3f\x00\x2b\x00\x40\x00\x41\x00\x2c\x00\x00\x00\x04\x00\x2d\x00\x04\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\xff\xff\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# -happyReduceArr = array (1, 136) [ - (1 , happyReduce_1), +happyReduceArr = array (2, 142) [ (2 , happyReduce_2), (3 , happyReduce_3), (4 , happyReduce_4), @@ -490,57 +495,112 @@ happyReduceArr = array (1, 136) [ (133 , happyReduce_133), (134 , happyReduce_134), (135 , happyReduce_135), - (136 , happyReduce_136) + (136 , happyReduce_136), + (137 , happyReduce_137), + (138 , happyReduce_138), + (139 , happyReduce_139), + (140 , happyReduce_140), + (141 , happyReduce_141), + (142 , happyReduce_142) ] happy_n_terms = 54 :: Int -happy_n_nonterms = 53 :: Int +happy_n_nonterms = 54 :: Int -happyReduce_1 = happySpecReduce_1 0# happyReduction_1 -happyReduction_1 happy_x_1 +happyReduce_2 = happySpecReduce_1 0# happyReduction_2 +happyReduction_2 happy_x_1 = case happyOutTok happy_x_1 of { (PT _ (TV happy_var_1)) -> - happyIn4 + happyIn5 (identC happy_var_1 --H )} -happyReduce_2 = happySpecReduce_1 1# happyReduction_2 -happyReduction_2 happy_x_1 +happyReduce_3 = happySpecReduce_1 1# happyReduction_3 +happyReduction_3 happy_x_1 = case happyOutTok happy_x_1 of { (PT _ (TL happy_var_1)) -> - happyIn5 + happyIn6 (happy_var_1 )} -happyReduce_3 = happySpecReduce_1 2# happyReduction_3 -happyReduction_3 happy_x_1 +happyReduce_4 = happySpecReduce_1 2# happyReduction_4 +happyReduction_4 happy_x_1 = case happyOutTok happy_x_1 of { (PT _ (TI happy_var_1)) -> - happyIn6 + happyIn7 ((read happy_var_1) :: Integer )} -happyReduce_4 = happyReduce 6# 3# happyReduction_4 -happyReduction_4 (happy_x_6 `HappyStk` +happyReduce_5 = happyReduce 6# 3# happyReduction_5 +happyReduction_5 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut56 happy_x_2 of { happy_var_2 -> - case happyOut4 happy_x_4 of { happy_var_4 -> - case happyOut10 happy_x_6 of { happy_var_6 -> - happyIn7 + = case happyOut58 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + case happyOut12 happy_x_6 of { happy_var_6 -> + happyIn8 (MGr happy_var_2 happy_var_4 (reverse happy_var_6) ) `HappyStk` happyRest}}} -happyReduce_5 = happySpecReduce_1 3# happyReduction_5 -happyReduction_5 happy_x_1 - = case happyOut10 happy_x_1 of { happy_var_1 -> - happyIn7 +happyReduce_6 = happySpecReduce_1 3# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + happyIn8 (Gr (reverse happy_var_1) )} -happyReduce_6 = happyReduce 8# 4# happyReduction_6 -happyReduction_6 (happy_x_8 `HappyStk` +happyReduce_7 = happyReduce 5# 4# happyReduction_7 +happyReduction_7 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut58 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + happyIn9 + (LMulti happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_8 = happyReduce 5# 4# happyReduction_8 +happyReduction_8 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut13 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + happyIn9 + (LHeader happy_var_1 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_9 = happySpecReduce_2 4# happyReduction_9 +happyReduction_9 happy_x_2 + happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn9 + (LFlag happy_var_1 + )} + +happyReduce_10 = happySpecReduce_2 4# happyReduction_10 +happyReduction_10 happy_x_2 + happy_x_1 + = case happyOut16 happy_x_1 of { happy_var_1 -> + happyIn9 + (LDef happy_var_1 + )} + +happyReduce_11 = happySpecReduce_1 4# happyReduction_11 +happyReduction_11 happy_x_1 + = happyIn9 + (LEnd + ) + +happyReduce_12 = happyReduce 8# 5# happyReduction_12 +happyReduction_12 (happy_x_8 `HappyStk` happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` @@ -549,113 +609,113 @@ happyReduction_6 (happy_x_8 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut11 happy_x_3 of { happy_var_3 -> - case happyOut12 happy_x_4 of { happy_var_4 -> - case happyOut42 happy_x_6 of { happy_var_6 -> - case happyOut43 happy_x_7 of { happy_var_7 -> - happyIn8 + = case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut13 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + case happyOut44 happy_x_6 of { happy_var_6 -> + case happyOut45 happy_x_7 of { happy_var_7 -> + happyIn10 (Mod happy_var_1 happy_var_3 happy_var_4 (reverse happy_var_6) (reverse happy_var_7) ) `HappyStk` happyRest}}}}} -happyReduce_7 = happySpecReduce_2 5# happyReduction_7 -happyReduction_7 happy_x_2 +happyReduce_13 = happySpecReduce_2 6# happyReduction_13 +happyReduction_13 happy_x_2 happy_x_1 - = case happyOut4 happy_x_2 of { happy_var_2 -> - happyIn9 + = case happyOut5 happy_x_2 of { happy_var_2 -> + happyIn11 (MTAbs happy_var_2 )} -happyReduce_8 = happyReduce 4# 5# happyReduction_8 -happyReduction_8 (happy_x_4 `HappyStk` +happyReduce_14 = happyReduce 4# 6# happyReduction_14 +happyReduction_14 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut4 happy_x_4 of { happy_var_4 -> - happyIn9 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + happyIn11 (MTCnc happy_var_2 happy_var_4 ) `HappyStk` happyRest}} -happyReduce_9 = happySpecReduce_2 5# happyReduction_9 -happyReduction_9 happy_x_2 +happyReduce_15 = happySpecReduce_2 6# happyReduction_15 +happyReduction_15 happy_x_2 happy_x_1 - = case happyOut4 happy_x_2 of { happy_var_2 -> - happyIn9 + = case happyOut5 happy_x_2 of { happy_var_2 -> + happyIn11 (MTRes happy_var_2 )} -happyReduce_10 = happyReduce 6# 5# happyReduction_10 -happyReduction_10 (happy_x_6 `HappyStk` +happyReduce_16 = happyReduce 6# 6# happyReduction_16 +happyReduction_16 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut4 happy_x_4 of { happy_var_4 -> - case happyOut4 happy_x_6 of { happy_var_6 -> - happyIn9 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + case happyOut5 happy_x_6 of { happy_var_6 -> + happyIn11 (MTTrans happy_var_2 happy_var_4 happy_var_6 ) `HappyStk` happyRest}}} -happyReduce_11 = happySpecReduce_0 6# happyReduction_11 -happyReduction_11 = happyIn10 +happyReduce_17 = happySpecReduce_0 7# happyReduction_17 +happyReduction_17 = happyIn12 ([] ) -happyReduce_12 = happySpecReduce_2 6# happyReduction_12 -happyReduction_12 happy_x_2 +happyReduce_18 = happySpecReduce_2 7# happyReduction_18 +happyReduction_18 happy_x_2 happy_x_1 - = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn10 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut10 happy_x_2 of { happy_var_2 -> + happyIn12 (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_13 = happySpecReduce_2 7# happyReduction_13 -happyReduction_13 happy_x_2 +happyReduce_19 = happySpecReduce_2 8# happyReduction_19 +happyReduction_19 happy_x_2 happy_x_1 - = case happyOut56 happy_x_1 of { happy_var_1 -> - happyIn11 + = case happyOut58 happy_x_1 of { happy_var_1 -> + happyIn13 (Ext happy_var_1 )} -happyReduce_14 = happySpecReduce_0 7# happyReduction_14 -happyReduction_14 = happyIn11 +happyReduce_20 = happySpecReduce_0 8# happyReduction_20 +happyReduction_20 = happyIn13 (NoExt ) -happyReduce_15 = happySpecReduce_3 8# happyReduction_15 -happyReduction_15 happy_x_3 +happyReduce_21 = happySpecReduce_3 9# happyReduction_21 +happyReduction_21 happy_x_3 happy_x_2 happy_x_1 - = case happyOut56 happy_x_2 of { happy_var_2 -> - happyIn12 + = case happyOut58 happy_x_2 of { happy_var_2 -> + happyIn14 (Opens happy_var_2 )} -happyReduce_16 = happySpecReduce_0 8# happyReduction_16 -happyReduction_16 = happyIn12 +happyReduce_22 = happySpecReduce_0 9# happyReduction_22 +happyReduction_22 = happyIn14 (NoOpens ) -happyReduce_17 = happyReduce 4# 9# happyReduction_17 -happyReduction_17 (happy_x_4 `HappyStk` +happyReduce_23 = happyReduce 4# 10# happyReduction_23 +happyReduction_23 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut4 happy_x_4 of { happy_var_4 -> - happyIn13 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + happyIn15 (Flg happy_var_2 happy_var_4 ) `HappyStk` happyRest}} -happyReduce_18 = happyReduce 7# 10# happyReduction_18 -happyReduction_18 (happy_x_7 `HappyStk` +happyReduce_24 = happyReduce 7# 11# happyReduction_24 +happyReduction_24 (happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` @@ -663,69 +723,69 @@ happyReduction_18 (happy_x_7 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_4 of { happy_var_4 -> - case happyOut46 happy_x_7 of { happy_var_7 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut26 happy_x_4 of { happy_var_4 -> + case happyOut48 happy_x_7 of { happy_var_7 -> + happyIn16 (AbsDCat happy_var_2 happy_var_4 (reverse happy_var_7) ) `HappyStk` happyRest}}} -happyReduce_19 = happyReduce 6# 10# happyReduction_19 -happyReduction_19 (happy_x_6 `HappyStk` +happyReduce_25 = happyReduce 6# 11# happyReduction_25 +happyReduction_25 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut19 happy_x_4 of { happy_var_4 -> - case happyOut19 happy_x_6 of { happy_var_6 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_4 of { happy_var_4 -> + case happyOut21 happy_x_6 of { happy_var_6 -> + happyIn16 (AbsDFun happy_var_2 happy_var_4 happy_var_6 ) `HappyStk` happyRest}}} -happyReduce_20 = happyReduce 4# 10# happyReduction_20 -happyReduction_20 (happy_x_4 `HappyStk` +happyReduce_26 = happyReduce 4# 11# happyReduction_26 +happyReduction_26 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut19 happy_x_4 of { happy_var_4 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_4 of { happy_var_4 -> + happyIn16 (AbsDTrans happy_var_2 happy_var_4 ) `HappyStk` happyRest}} -happyReduce_21 = happyReduce 4# 10# happyReduction_21 -happyReduction_21 (happy_x_4 `HappyStk` +happyReduce_27 = happyReduce 4# 11# happyReduction_27 +happyReduction_27 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut44 happy_x_4 of { happy_var_4 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut46 happy_x_4 of { happy_var_4 -> + happyIn16 (ResDPar happy_var_2 happy_var_4 ) `HappyStk` happyRest}} -happyReduce_22 = happyReduce 6# 10# happyReduction_22 -happyReduction_22 (happy_x_6 `HappyStk` +happyReduce_28 = happyReduce 6# 11# happyReduction_28 +happyReduction_28 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - case happyOut33 happy_x_6 of { happy_var_6 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut31 happy_x_4 of { happy_var_4 -> + case happyOut35 happy_x_6 of { happy_var_6 -> + happyIn16 (ResDOper happy_var_2 happy_var_4 happy_var_6 ) `HappyStk` happyRest}}} -happyReduce_23 = happyReduce 8# 10# happyReduction_23 -happyReduction_23 (happy_x_8 `HappyStk` +happyReduce_29 = happyReduce 8# 11# happyReduction_29 +happyReduction_29 (happy_x_8 `HappyStk` happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` @@ -734,16 +794,16 @@ happyReduction_23 (happy_x_8 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - case happyOut33 happy_x_6 of { happy_var_6 -> - case happyOut33 happy_x_8 of { happy_var_8 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut31 happy_x_4 of { happy_var_4 -> + case happyOut35 happy_x_6 of { happy_var_6 -> + case happyOut35 happy_x_8 of { happy_var_8 -> + happyIn16 (CncDCat happy_var_2 happy_var_4 happy_var_6 happy_var_8 ) `HappyStk` happyRest}}}} -happyReduce_24 = happyReduce 11# 10# happyReduction_24 -happyReduction_24 (happy_x_11 `HappyStk` +happyReduce_30 = happyReduce 11# 11# happyReduction_30 +happyReduction_30 (happy_x_11 `HappyStk` happy_x_10 `HappyStk` happy_x_9 `HappyStk` happy_x_8 `HappyStk` @@ -755,76 +815,76 @@ happyReduction_24 (happy_x_11 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut17 happy_x_4 of { happy_var_4 -> - case happyOut48 happy_x_7 of { happy_var_7 -> - case happyOut33 happy_x_9 of { happy_var_9 -> - case happyOut33 happy_x_11 of { happy_var_11 -> - happyIn14 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut19 happy_x_4 of { happy_var_4 -> + case happyOut50 happy_x_7 of { happy_var_7 -> + case happyOut35 happy_x_9 of { happy_var_9 -> + case happyOut35 happy_x_11 of { happy_var_11 -> + happyIn16 (CncDFun happy_var_2 happy_var_4 happy_var_7 happy_var_9 happy_var_11 ) `HappyStk` happyRest}}}}} -happyReduce_25 = happyReduce 4# 10# happyReduction_25 -happyReduction_25 (happy_x_4 `HappyStk` +happyReduce_31 = happyReduce 4# 11# happyReduction_31 +happyReduction_31 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut16 happy_x_2 of { happy_var_2 -> - case happyOut4 happy_x_4 of { happy_var_4 -> - happyIn14 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_2 of { happy_var_2 -> + case happyOut5 happy_x_4 of { happy_var_4 -> + happyIn16 (AnyDInd happy_var_1 happy_var_2 happy_var_4 ) `HappyStk` happyRest}}} -happyReduce_26 = happySpecReduce_2 11# happyReduction_26 -happyReduction_26 happy_x_2 +happyReduce_32 = happySpecReduce_2 12# happyReduction_32 +happyReduction_32 happy_x_2 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut45 happy_x_2 of { happy_var_2 -> - happyIn15 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_2 of { happy_var_2 -> + happyIn17 (ParD happy_var_1 (reverse happy_var_2) )}} -happyReduce_27 = happySpecReduce_1 12# happyReduction_27 -happyReduction_27 happy_x_1 - = happyIn16 +happyReduce_33 = happySpecReduce_1 13# happyReduction_33 +happyReduction_33 happy_x_1 + = happyIn18 (Canon ) -happyReduce_28 = happySpecReduce_0 12# happyReduction_28 -happyReduction_28 = happyIn16 +happyReduce_34 = happySpecReduce_0 13# happyReduction_34 +happyReduction_34 = happyIn18 (NonCan ) -happyReduce_29 = happySpecReduce_3 13# happyReduction_29 -happyReduction_29 happy_x_3 +happyReduce_35 = happySpecReduce_3 14# happyReduction_35 +happyReduction_35 happy_x_3 happy_x_2 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut4 happy_x_3 of { happy_var_3 -> - happyIn17 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut5 happy_x_3 of { happy_var_3 -> + happyIn19 (CIQ happy_var_1 happy_var_3 )}} -happyReduce_30 = happySpecReduce_2 14# happyReduction_30 -happyReduction_30 happy_x_2 +happyReduce_36 = happySpecReduce_2 15# happyReduction_36 +happyReduction_36 happy_x_2 happy_x_1 - = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_2 of { happy_var_2 -> - happyIn18 + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn20 (EApp happy_var_1 happy_var_2 )}} -happyReduce_31 = happySpecReduce_1 14# happyReduction_31 -happyReduction_31 happy_x_1 - = case happyOut20 happy_x_1 of { happy_var_1 -> - happyIn18 +happyReduce_37 = happySpecReduce_1 15# happyReduction_37 +happyReduction_37 happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn20 (happy_var_1 )} -happyReduce_32 = happyReduce 7# 15# happyReduction_32 -happyReduction_32 (happy_x_7 `HappyStk` +happyReduce_38 = happyReduce 7# 16# happyReduction_38 +happyReduction_38 (happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` @@ -832,448 +892,448 @@ happyReduction_32 (happy_x_7 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut19 happy_x_4 of { happy_var_4 -> - case happyOut19 happy_x_7 of { happy_var_7 -> - happyIn19 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_4 of { happy_var_4 -> + case happyOut21 happy_x_7 of { happy_var_7 -> + happyIn21 (EProd happy_var_2 happy_var_4 happy_var_7 ) `HappyStk` happyRest}}} -happyReduce_33 = happyReduce 4# 15# happyReduction_33 -happyReduction_33 (happy_x_4 `HappyStk` +happyReduce_39 = happyReduce 4# 16# happyReduction_39 +happyReduction_39 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_2 of { happy_var_2 -> - case happyOut19 happy_x_4 of { happy_var_4 -> - happyIn19 + = case happyOut5 happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_4 of { happy_var_4 -> + happyIn21 (EAbs happy_var_2 happy_var_4 ) `HappyStk` happyRest}} -happyReduce_34 = happySpecReduce_3 15# happyReduction_34 -happyReduction_34 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut26 happy_x_2 of { happy_var_2 -> - happyIn19 - (EEq (reverse happy_var_2) - )} - -happyReduce_35 = happySpecReduce_1 15# happyReduction_35 -happyReduction_35 happy_x_1 - = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn19 - (happy_var_1 - )} - -happyReduce_36 = happySpecReduce_1 16# happyReduction_36 -happyReduction_36 happy_x_1 - = case happyOut27 happy_x_1 of { happy_var_1 -> - happyIn20 - (EAtom happy_var_1 - )} - -happyReduce_37 = happySpecReduce_1 16# happyReduction_37 -happyReduction_37 happy_x_1 - = happyIn20 - (EData - ) - -happyReduce_38 = happySpecReduce_3 16# happyReduction_38 -happyReduction_38 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn20 - (happy_var_2 - )} - -happyReduce_39 = happySpecReduce_1 17# happyReduction_39 -happyReduction_39 happy_x_1 - = happyIn21 - (SType - ) - -happyReduce_40 = happySpecReduce_3 18# happyReduction_40 +happyReduce_40 = happySpecReduce_3 16# happyReduction_40 happyReduction_40 happy_x_3 happy_x_2 happy_x_1 - = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> + = case happyOut28 happy_x_2 of { happy_var_2 -> + happyIn21 + (EEq (reverse happy_var_2) + )} + +happyReduce_41 = happySpecReduce_1 16# happyReduction_41 +happyReduction_41 happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + happyIn21 + (happy_var_1 + )} + +happyReduce_42 = happySpecReduce_1 17# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut29 happy_x_1 of { happy_var_1 -> happyIn22 + (EAtom happy_var_1 + )} + +happyReduce_43 = happySpecReduce_1 17# happyReduction_43 +happyReduction_43 happy_x_1 + = happyIn22 + (EData + ) + +happyReduce_44 = happySpecReduce_3 17# happyReduction_44 +happyReduction_44 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut21 happy_x_2 of { happy_var_2 -> + happyIn22 + (happy_var_2 + )} + +happyReduce_45 = happySpecReduce_1 18# happyReduction_45 +happyReduction_45 happy_x_1 + = happyIn23 + (SType + ) + +happyReduce_46 = happySpecReduce_3 19# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + happyIn24 (Equ (reverse happy_var_1) happy_var_3 )}} -happyReduce_41 = happyReduce 4# 19# happyReduction_41 -happyReduction_41 (happy_x_4 `HappyStk` +happyReduce_47 = happyReduce 4# 20# happyReduction_47 +happyReduction_47 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut17 happy_x_2 of { happy_var_2 -> - case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn23 + = case happyOut19 happy_x_2 of { happy_var_2 -> + case happyOut27 happy_x_3 of { happy_var_3 -> + happyIn25 (APC happy_var_2 (reverse happy_var_3) ) `HappyStk` happyRest}} -happyReduce_42 = happySpecReduce_1 19# happyReduction_42 -happyReduction_42 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - happyIn23 +happyReduce_48 = happySpecReduce_1 20# happyReduction_48 +happyReduction_48 happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + happyIn25 (APV happy_var_1 )} -happyReduce_43 = happySpecReduce_1 19# happyReduction_43 -happyReduction_43 happy_x_1 - = case happyOut5 happy_x_1 of { happy_var_1 -> - happyIn23 +happyReduce_49 = happySpecReduce_1 20# happyReduction_49 +happyReduction_49 happy_x_1 + = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn25 (APS happy_var_1 )} -happyReduce_44 = happySpecReduce_1 19# happyReduction_44 -happyReduction_44 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn23 +happyReduce_50 = happySpecReduce_1 20# happyReduction_50 +happyReduction_50 happy_x_1 + = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn25 (API happy_var_1 )} -happyReduce_45 = happySpecReduce_1 19# happyReduction_45 -happyReduction_45 happy_x_1 - = happyIn23 +happyReduce_51 = happySpecReduce_1 20# happyReduction_51 +happyReduction_51 happy_x_1 + = happyIn25 (APW ) -happyReduce_46 = happySpecReduce_0 20# happyReduction_46 -happyReduction_46 = happyIn24 +happyReduce_52 = happySpecReduce_0 21# happyReduction_52 +happyReduction_52 = happyIn26 ([] ) -happyReduce_47 = happySpecReduce_1 20# happyReduction_47 -happyReduction_47 happy_x_1 - = case happyOut28 happy_x_1 of { happy_var_1 -> - happyIn24 +happyReduce_53 = happySpecReduce_1 21# happyReduction_53 +happyReduction_53 happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + happyIn26 ((:[]) happy_var_1 )} -happyReduce_48 = happySpecReduce_3 20# happyReduction_48 -happyReduction_48 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn24 - ((:) happy_var_1 happy_var_3 - )}} - -happyReduce_49 = happySpecReduce_0 21# happyReduction_49 -happyReduction_49 = happyIn25 - ([] - ) - -happyReduce_50 = happySpecReduce_2 21# happyReduction_50 -happyReduction_50 happy_x_2 - happy_x_1 - = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn25 - (flip (:) happy_var_1 happy_var_2 - )}} - -happyReduce_51 = happySpecReduce_0 22# happyReduction_51 -happyReduction_51 = happyIn26 - ([] - ) - -happyReduce_52 = happySpecReduce_3 22# happyReduction_52 -happyReduction_52 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut26 happy_x_1 of { happy_var_1 -> - case happyOut22 happy_x_2 of { happy_var_2 -> - happyIn26 - (flip (:) happy_var_1 happy_var_2 - )}} - -happyReduce_53 = happySpecReduce_1 23# happyReduction_53 -happyReduction_53 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn27 - (AC happy_var_1 - )} - -happyReduce_54 = happySpecReduce_3 23# happyReduction_54 +happyReduce_54 = happySpecReduce_3 21# happyReduction_54 happyReduction_54 happy_x_3 happy_x_2 happy_x_1 - = case happyOut17 happy_x_2 of { happy_var_2 -> - happyIn27 - (AD happy_var_2 - )} + = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn26 + ((:) happy_var_1 happy_var_3 + )}} -happyReduce_55 = happySpecReduce_2 23# happyReduction_55 -happyReduction_55 happy_x_2 - happy_x_1 - = case happyOut4 happy_x_2 of { happy_var_2 -> - happyIn27 - (AV happy_var_2 - )} +happyReduce_55 = happySpecReduce_0 22# happyReduction_55 +happyReduction_55 = happyIn27 + ([] + ) -happyReduce_56 = happySpecReduce_2 23# happyReduction_56 +happyReduce_56 = happySpecReduce_2 22# happyReduction_56 happyReduction_56 happy_x_2 happy_x_1 - = case happyOut6 happy_x_2 of { happy_var_2 -> + = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_2 of { happy_var_2 -> happyIn27 - (AM happy_var_2 - )} + (flip (:) happy_var_1 happy_var_2 + )}} -happyReduce_57 = happySpecReduce_1 23# happyReduction_57 -happyReduction_57 happy_x_1 - = case happyOut5 happy_x_1 of { happy_var_1 -> - happyIn27 - (AS happy_var_1 - )} +happyReduce_57 = happySpecReduce_0 23# happyReduction_57 +happyReduction_57 = happyIn28 + ([] + ) -happyReduce_58 = happySpecReduce_1 23# happyReduction_58 -happyReduction_58 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn27 - (AI happy_var_1 - )} +happyReduce_58 = happySpecReduce_3 23# happyReduction_58 +happyReduction_58 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn28 + (flip (:) happy_var_1 happy_var_2 + )}} -happyReduce_59 = happySpecReduce_1 23# happyReduction_59 +happyReduce_59 = happySpecReduce_1 24# happyReduction_59 happyReduction_59 happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn27 - (AT happy_var_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn29 + (AC happy_var_1 )} happyReduce_60 = happySpecReduce_3 24# happyReduction_60 happyReduction_60 happy_x_3 happy_x_2 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn28 - (Decl happy_var_1 happy_var_3 - )}} - -happyReduce_61 = happySpecReduce_3 25# happyReduction_61 -happyReduction_61 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> + = case happyOut19 happy_x_2 of { happy_var_2 -> happyIn29 - (RecType happy_var_2 + (AD happy_var_2 )} -happyReduce_62 = happyReduce 5# 25# happyReduction_62 -happyReduction_62 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> +happyReduce_61 = happySpecReduce_2 24# happyReduction_61 +happyReduction_61 happy_x_2 + happy_x_1 + = case happyOut5 happy_x_2 of { happy_var_2 -> happyIn29 - (Table happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} + (AV happy_var_2 + )} -happyReduce_63 = happySpecReduce_1 25# happyReduction_63 +happyReduce_62 = happySpecReduce_2 24# happyReduction_62 +happyReduction_62 happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn29 + (AM happy_var_2 + )} + +happyReduce_63 = happySpecReduce_1 24# happyReduction_63 happyReduction_63 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> + = case happyOut6 happy_x_1 of { happy_var_1 -> happyIn29 - (Cn happy_var_1 + (AS happy_var_1 )} -happyReduce_64 = happySpecReduce_1 25# happyReduction_64 +happyReduce_64 = happySpecReduce_1 24# happyReduction_64 happyReduction_64 happy_x_1 - = happyIn29 - (TStr - ) - -happyReduce_65 = happySpecReduce_2 25# happyReduction_65 -happyReduction_65 happy_x_2 - happy_x_1 - = case happyOut6 happy_x_2 of { happy_var_2 -> + = case happyOut7 happy_x_1 of { happy_var_1 -> happyIn29 - (TInts happy_var_2 + (AI happy_var_1 )} -happyReduce_66 = happySpecReduce_3 26# happyReduction_66 +happyReduce_65 = happySpecReduce_1 24# happyReduction_65 +happyReduction_65 happy_x_1 + = case happyOut23 happy_x_1 of { happy_var_1 -> + happyIn29 + (AT happy_var_1 + )} + +happyReduce_66 = happySpecReduce_3 25# happyReduction_66 happyReduction_66 happy_x_3 happy_x_2 happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> happyIn30 + (Decl happy_var_1 happy_var_3 + )}} + +happyReduce_67 = happySpecReduce_3 26# happyReduction_67 +happyReduction_67 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut51 happy_x_2 of { happy_var_2 -> + happyIn31 + (RecType happy_var_2 + )} + +happyReduce_68 = happyReduce 5# 26# happyReduction_68 +happyReduction_68 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut31 happy_x_2 of { happy_var_2 -> + case happyOut31 happy_x_4 of { happy_var_4 -> + happyIn31 + (Table happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_69 = happySpecReduce_1 26# happyReduction_69 +happyReduction_69 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn31 + (Cn happy_var_1 + )} + +happyReduce_70 = happySpecReduce_1 26# happyReduction_70 +happyReduction_70 happy_x_1 + = happyIn31 + (TStr + ) + +happyReduce_71 = happySpecReduce_2 26# happyReduction_71 +happyReduction_71 happy_x_2 + happy_x_1 + = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn31 + (TInts happy_var_2 + )} + +happyReduce_72 = happySpecReduce_3 27# happyReduction_72 +happyReduction_72 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_3 of { happy_var_3 -> + happyIn32 (Lbg happy_var_1 happy_var_3 )}} -happyReduce_67 = happySpecReduce_1 27# happyReduction_67 -happyReduction_67 happy_x_1 - = case happyOut39 happy_x_1 of { happy_var_1 -> - happyIn31 +happyReduce_73 = happySpecReduce_1 28# happyReduction_73 +happyReduction_73 happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn33 (Arg happy_var_1 )} -happyReduce_68 = happySpecReduce_1 27# happyReduction_68 -happyReduction_68 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn31 +happyReduce_74 = happySpecReduce_1 28# happyReduction_74 +happyReduction_74 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn33 (I happy_var_1 )} -happyReduce_69 = happyReduce 4# 27# happyReduction_69 -happyReduction_69 (happy_x_4 `HappyStk` +happyReduce_75 = happyReduce 4# 28# happyReduction_75 +happyReduction_75 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut17 happy_x_2 of { happy_var_2 -> - case happyOut51 happy_x_3 of { happy_var_3 -> - happyIn31 + = case happyOut19 happy_x_2 of { happy_var_2 -> + case happyOut53 happy_x_3 of { happy_var_3 -> + happyIn33 (Con happy_var_2 (reverse happy_var_3) ) `HappyStk` happyRest}} -happyReduce_70 = happySpecReduce_2 27# happyReduction_70 -happyReduction_70 happy_x_2 +happyReduce_76 = happySpecReduce_2 28# happyReduction_76 +happyReduction_76 happy_x_2 happy_x_1 - = case happyOut4 happy_x_2 of { happy_var_2 -> - happyIn31 + = case happyOut5 happy_x_2 of { happy_var_2 -> + happyIn33 (LI happy_var_2 )} -happyReduce_71 = happySpecReduce_3 27# happyReduction_71 -happyReduction_71 happy_x_3 +happyReduce_77 = happySpecReduce_3 28# happyReduction_77 +happyReduction_77 happy_x_3 happy_x_2 happy_x_1 - = case happyOut47 happy_x_2 of { happy_var_2 -> - happyIn31 + = case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn33 (R happy_var_2 )} -happyReduce_72 = happySpecReduce_1 27# happyReduction_72 -happyReduction_72 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn31 +happyReduce_78 = happySpecReduce_1 28# happyReduction_78 +happyReduction_78 happy_x_1 + = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn33 (EInt happy_var_1 )} -happyReduce_73 = happySpecReduce_1 27# happyReduction_73 -happyReduction_73 happy_x_1 - = case happyOut34 happy_x_1 of { happy_var_1 -> - happyIn31 +happyReduce_79 = happySpecReduce_1 28# happyReduction_79 +happyReduction_79 happy_x_1 + = case happyOut36 happy_x_1 of { happy_var_1 -> + happyIn33 (K happy_var_1 )} -happyReduce_74 = happySpecReduce_2 27# happyReduction_74 -happyReduction_74 happy_x_2 +happyReduce_80 = happySpecReduce_2 28# happyReduction_80 +happyReduction_80 happy_x_2 happy_x_1 - = happyIn31 + = happyIn33 (E ) -happyReduce_75 = happySpecReduce_3 27# happyReduction_75 -happyReduction_75 happy_x_3 +happyReduce_81 = happySpecReduce_3 28# happyReduction_81 +happyReduction_81 happy_x_3 happy_x_2 happy_x_1 - = case happyOut33 happy_x_2 of { happy_var_2 -> - happyIn31 + = case happyOut35 happy_x_2 of { happy_var_2 -> + happyIn33 (happy_var_2 )} -happyReduce_76 = happySpecReduce_3 28# happyReduction_76 -happyReduction_76 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - case happyOut38 happy_x_3 of { happy_var_3 -> - happyIn32 - (P happy_var_1 happy_var_3 - )}} - -happyReduce_77 = happyReduce 5# 28# happyReduction_77 -happyReduction_77 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOut50 happy_x_4 of { happy_var_4 -> - happyIn32 - (T happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_78 = happyReduce 5# 28# happyReduction_78 -happyReduction_78 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOut51 happy_x_4 of { happy_var_4 -> - happyIn32 - (V happy_var_2 (reverse happy_var_4) - ) `HappyStk` happyRest}} - -happyReduce_79 = happySpecReduce_3 28# happyReduction_79 -happyReduction_79 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut32 happy_x_1 of { happy_var_1 -> - case happyOut31 happy_x_3 of { happy_var_3 -> - happyIn32 - (S happy_var_1 happy_var_3 - )}} - -happyReduce_80 = happyReduce 4# 28# happyReduction_80 -happyReduction_80 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut51 happy_x_3 of { happy_var_3 -> - happyIn32 - (FV (reverse happy_var_3) - ) `HappyStk` happyRest} - -happyReduce_81 = happySpecReduce_1 28# happyReduction_81 -happyReduction_81 happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - happyIn32 - (happy_var_1 - )} - happyReduce_82 = happySpecReduce_3 29# happyReduction_82 happyReduction_82 happy_x_3 happy_x_2 happy_x_1 = case happyOut33 happy_x_1 of { happy_var_1 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn33 - (C happy_var_1 happy_var_3 + case happyOut40 happy_x_3 of { happy_var_3 -> + happyIn34 + (P happy_var_1 happy_var_3 )}} -happyReduce_83 = happySpecReduce_1 29# happyReduction_83 -happyReduction_83 happy_x_1 - = case happyOut32 happy_x_1 of { happy_var_1 -> - happyIn33 +happyReduce_83 = happyReduce 5# 29# happyReduction_83 +happyReduction_83 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut31 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + happyIn34 + (T happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_84 = happyReduce 5# 29# happyReduction_84 +happyReduction_84 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut31 happy_x_2 of { happy_var_2 -> + case happyOut53 happy_x_4 of { happy_var_4 -> + happyIn34 + (V happy_var_2 (reverse happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_85 = happySpecReduce_3 29# happyReduction_85 +happyReduction_85 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut34 happy_x_1 of { happy_var_1 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + happyIn34 + (S happy_var_1 happy_var_3 + )}} + +happyReduce_86 = happyReduce 4# 29# happyReduction_86 +happyReduction_86 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut53 happy_x_3 of { happy_var_3 -> + happyIn34 + (FV (reverse happy_var_3) + ) `HappyStk` happyRest} + +happyReduce_87 = happySpecReduce_1 29# happyReduction_87 +happyReduction_87 happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn34 (happy_var_1 )} -happyReduce_84 = happySpecReduce_1 30# happyReduction_84 -happyReduction_84 happy_x_1 - = case happyOut5 happy_x_1 of { happy_var_1 -> - happyIn34 +happyReduce_88 = happySpecReduce_3 30# happyReduction_88 +happyReduction_88 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut35 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_3 of { happy_var_3 -> + happyIn35 + (C happy_var_1 happy_var_3 + )}} + +happyReduce_89 = happySpecReduce_1 30# happyReduction_89 +happyReduction_89 happy_x_1 + = case happyOut34 happy_x_1 of { happy_var_1 -> + happyIn35 + (happy_var_1 + )} + +happyReduce_90 = happySpecReduce_1 31# happyReduction_90 +happyReduction_90 happy_x_1 + = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn36 (KS happy_var_1 )} -happyReduce_85 = happyReduce 7# 30# happyReduction_85 -happyReduction_85 (happy_x_7 `HappyStk` +happyReduce_91 = happyReduce 7# 31# happyReduction_91 +happyReduction_91 (happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` @@ -1281,408 +1341,408 @@ happyReduction_85 (happy_x_7 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut52 happy_x_3 of { happy_var_3 -> - case happyOut53 happy_x_5 of { happy_var_5 -> - happyIn34 + = case happyOut54 happy_x_3 of { happy_var_3 -> + case happyOut55 happy_x_5 of { happy_var_5 -> + happyIn36 (KP (reverse happy_var_3) happy_var_5 ) `HappyStk` happyRest}} -happyReduce_86 = happySpecReduce_3 31# happyReduction_86 -happyReduction_86 happy_x_3 +happyReduce_92 = happySpecReduce_3 32# happyReduction_92 +happyReduction_92 happy_x_3 happy_x_2 happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn35 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn37 (Ass happy_var_1 happy_var_3 )}} -happyReduce_87 = happySpecReduce_3 32# happyReduction_87 -happyReduction_87 happy_x_3 +happyReduce_93 = happySpecReduce_3 33# happyReduction_93 +happyReduction_93 happy_x_3 happy_x_2 happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn36 + = case happyOut57 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn38 (Cas (reverse happy_var_1) happy_var_3 )}} -happyReduce_88 = happySpecReduce_3 33# happyReduction_88 -happyReduction_88 happy_x_3 +happyReduce_94 = happySpecReduce_3 34# happyReduction_94 +happyReduction_94 happy_x_3 happy_x_2 happy_x_1 - = case happyOut52 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - happyIn37 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut54 happy_x_3 of { happy_var_3 -> + happyIn39 (Var (reverse happy_var_1) (reverse happy_var_3) )}} -happyReduce_89 = happySpecReduce_1 34# happyReduction_89 -happyReduction_89 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - happyIn38 +happyReduce_95 = happySpecReduce_1 35# happyReduction_95 +happyReduction_95 happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + happyIn40 (L happy_var_1 )} -happyReduce_90 = happySpecReduce_2 34# happyReduction_90 -happyReduction_90 happy_x_2 +happyReduce_96 = happySpecReduce_2 35# happyReduction_96 +happyReduction_96 happy_x_2 happy_x_1 - = case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn38 + = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn40 (LV happy_var_2 )} -happyReduce_91 = happySpecReduce_3 35# happyReduction_91 -happyReduction_91 happy_x_3 +happyReduce_97 = happySpecReduce_3 36# happyReduction_97 +happyReduction_97 happy_x_3 happy_x_2 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn39 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn41 (A happy_var_1 happy_var_3 )}} -happyReduce_92 = happyReduce 5# 35# happyReduction_92 -happyReduction_92 (happy_x_5 `HappyStk` +happyReduce_98 = happyReduce 5# 36# happyReduction_98 +happyReduction_98 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut4 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn39 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn41 (AB happy_var_1 happy_var_3 happy_var_5 ) `HappyStk` happyRest}}} -happyReduce_93 = happyReduce 4# 36# happyReduction_93 -happyReduction_93 (happy_x_4 `HappyStk` +happyReduce_99 = happyReduce 4# 37# happyReduction_99 +happyReduction_99 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) - = case happyOut17 happy_x_2 of { happy_var_2 -> - case happyOut55 happy_x_3 of { happy_var_3 -> - happyIn40 + = case happyOut19 happy_x_2 of { happy_var_2 -> + case happyOut57 happy_x_3 of { happy_var_3 -> + happyIn42 (PC happy_var_2 (reverse happy_var_3) ) `HappyStk` happyRest}} -happyReduce_94 = happySpecReduce_1 36# happyReduction_94 -happyReduction_94 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> - happyIn40 +happyReduce_100 = happySpecReduce_1 37# happyReduction_100 +happyReduction_100 happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + happyIn42 (PV happy_var_1 )} -happyReduce_95 = happySpecReduce_1 36# happyReduction_95 -happyReduction_95 happy_x_1 - = happyIn40 +happyReduce_101 = happySpecReduce_1 37# happyReduction_101 +happyReduction_101 happy_x_1 + = happyIn42 (PW ) -happyReduce_96 = happySpecReduce_3 36# happyReduction_96 -happyReduction_96 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut54 happy_x_2 of { happy_var_2 -> - happyIn40 - (PR happy_var_2 - )} - -happyReduce_97 = happySpecReduce_1 36# happyReduction_97 -happyReduction_97 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn40 - (PI happy_var_1 - )} - -happyReduce_98 = happySpecReduce_3 37# happyReduction_98 -happyReduction_98 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_3 of { happy_var_3 -> - happyIn41 - (PAss happy_var_1 happy_var_3 - )}} - -happyReduce_99 = happySpecReduce_0 38# happyReduction_99 -happyReduction_99 = happyIn42 - ([] - ) - -happyReduce_100 = happySpecReduce_3 38# happyReduction_100 -happyReduction_100 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut42 happy_x_1 of { happy_var_1 -> - case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn42 - (flip (:) happy_var_1 happy_var_2 - )}} - -happyReduce_101 = happySpecReduce_0 39# happyReduction_101 -happyReduction_101 = happyIn43 - ([] - ) - -happyReduce_102 = happySpecReduce_3 39# happyReduction_102 +happyReduce_102 = happySpecReduce_3 37# happyReduction_102 happyReduction_102 happy_x_3 happy_x_2 happy_x_1 - = case happyOut43 happy_x_1 of { happy_var_1 -> - case happyOut14 happy_x_2 of { happy_var_2 -> + = case happyOut56 happy_x_2 of { happy_var_2 -> + happyIn42 + (PR happy_var_2 + )} + +happyReduce_103 = happySpecReduce_1 37# happyReduction_103 +happyReduction_103 happy_x_1 + = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn42 + (PI happy_var_1 + )} + +happyReduce_104 = happySpecReduce_3 38# happyReduction_104 +happyReduction_104 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_3 of { happy_var_3 -> happyIn43 + (PAss happy_var_1 happy_var_3 + )}} + +happyReduce_105 = happySpecReduce_0 39# happyReduction_105 +happyReduction_105 = happyIn44 + ([] + ) + +happyReduce_106 = happySpecReduce_3 39# happyReduction_106 +happyReduction_106 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + happyIn44 (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_103 = happySpecReduce_0 40# happyReduction_103 -happyReduction_103 = happyIn44 +happyReduce_107 = happySpecReduce_0 40# happyReduction_107 +happyReduction_107 = happyIn45 ([] ) -happyReduce_104 = happySpecReduce_1 40# happyReduction_104 -happyReduction_104 happy_x_1 - = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn44 - ((:[]) happy_var_1 - )} - -happyReduce_105 = happySpecReduce_3 40# happyReduction_105 -happyReduction_105 happy_x_3 +happyReduce_108 = happySpecReduce_3 40# happyReduction_108 +happyReduction_108 happy_x_3 happy_x_2 - happy_x_1 - = case happyOut15 happy_x_1 of { happy_var_1 -> - case happyOut44 happy_x_3 of { happy_var_3 -> - happyIn44 - ((:) happy_var_1 happy_var_3 - )}} - -happyReduce_106 = happySpecReduce_0 41# happyReduction_106 -happyReduction_106 = happyIn45 - ([] - ) - -happyReduce_107 = happySpecReduce_2 41# happyReduction_107 -happyReduction_107 happy_x_2 happy_x_1 = case happyOut45 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_2 of { happy_var_2 -> happyIn45 (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_108 = happySpecReduce_0 42# happyReduction_108 -happyReduction_108 = happyIn46 +happyReduce_109 = happySpecReduce_0 41# happyReduction_109 +happyReduction_109 = happyIn46 ([] ) -happyReduce_109 = happySpecReduce_2 42# happyReduction_109 -happyReduction_109 happy_x_2 - happy_x_1 - = case happyOut46 happy_x_1 of { happy_var_1 -> - case happyOut17 happy_x_2 of { happy_var_2 -> +happyReduce_110 = happySpecReduce_1 41# happyReduction_110 +happyReduction_110 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> happyIn46 + ((:[]) happy_var_1 + )} + +happyReduce_111 = happySpecReduce_3 41# happyReduction_111 +happyReduction_111 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn46 + ((:) happy_var_1 happy_var_3 + )}} + +happyReduce_112 = happySpecReduce_0 42# happyReduction_112 +happyReduction_112 = happyIn47 + ([] + ) + +happyReduce_113 = happySpecReduce_2 42# happyReduction_113 +happyReduction_113 happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn47 (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_110 = happySpecReduce_0 43# happyReduction_110 -happyReduction_110 = happyIn47 +happyReduce_114 = happySpecReduce_0 43# happyReduction_114 +happyReduction_114 = happyIn48 ([] ) -happyReduce_111 = happySpecReduce_1 43# happyReduction_111 -happyReduction_111 happy_x_1 - = case happyOut35 happy_x_1 of { happy_var_1 -> - happyIn47 - ((:[]) happy_var_1 - )} - -happyReduce_112 = happySpecReduce_3 43# happyReduction_112 -happyReduction_112 happy_x_3 - happy_x_2 +happyReduce_115 = happySpecReduce_2 43# happyReduction_115 +happyReduction_115 happy_x_2 happy_x_1 - = case happyOut35 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - happyIn47 - ((:) happy_var_1 happy_var_3 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_2 of { happy_var_2 -> + happyIn48 + (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_113 = happySpecReduce_0 44# happyReduction_113 -happyReduction_113 = happyIn48 - ([] - ) - -happyReduce_114 = happySpecReduce_1 44# happyReduction_114 -happyReduction_114 happy_x_1 - = case happyOut39 happy_x_1 of { happy_var_1 -> - happyIn48 - ((:[]) happy_var_1 - )} - -happyReduce_115 = happySpecReduce_3 44# happyReduction_115 -happyReduction_115 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut39 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_3 of { happy_var_3 -> - happyIn48 - ((:) happy_var_1 happy_var_3 - )}} - -happyReduce_116 = happySpecReduce_0 45# happyReduction_116 +happyReduce_116 = happySpecReduce_0 44# happyReduction_116 happyReduction_116 = happyIn49 ([] ) -happyReduce_117 = happySpecReduce_1 45# happyReduction_117 +happyReduce_117 = happySpecReduce_1 44# happyReduction_117 happyReduction_117 happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> + = case happyOut37 happy_x_1 of { happy_var_1 -> happyIn49 ((:[]) happy_var_1 )} -happyReduce_118 = happySpecReduce_3 45# happyReduction_118 +happyReduce_118 = happySpecReduce_3 44# happyReduction_118 happyReduction_118 happy_x_3 happy_x_2 happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> + = case happyOut37 happy_x_1 of { happy_var_1 -> case happyOut49 happy_x_3 of { happy_var_3 -> happyIn49 ((:) happy_var_1 happy_var_3 )}} -happyReduce_119 = happySpecReduce_0 46# happyReduction_119 +happyReduce_119 = happySpecReduce_0 45# happyReduction_119 happyReduction_119 = happyIn50 ([] ) -happyReduce_120 = happySpecReduce_1 46# happyReduction_120 +happyReduce_120 = happySpecReduce_1 45# happyReduction_120 happyReduction_120 happy_x_1 - = case happyOut36 happy_x_1 of { happy_var_1 -> + = case happyOut41 happy_x_1 of { happy_var_1 -> happyIn50 ((:[]) happy_var_1 )} -happyReduce_121 = happySpecReduce_3 46# happyReduction_121 +happyReduce_121 = happySpecReduce_3 45# happyReduction_121 happyReduction_121 happy_x_3 happy_x_2 happy_x_1 - = case happyOut36 happy_x_1 of { happy_var_1 -> + = case happyOut41 happy_x_1 of { happy_var_1 -> case happyOut50 happy_x_3 of { happy_var_3 -> happyIn50 ((:) happy_var_1 happy_var_3 )}} -happyReduce_122 = happySpecReduce_0 47# happyReduction_122 +happyReduce_122 = happySpecReduce_0 46# happyReduction_122 happyReduction_122 = happyIn51 ([] ) -happyReduce_123 = happySpecReduce_2 47# happyReduction_123 -happyReduction_123 happy_x_2 - happy_x_1 - = case happyOut51 happy_x_1 of { happy_var_1 -> - case happyOut31 happy_x_2 of { happy_var_2 -> +happyReduce_123 = happySpecReduce_1 46# happyReduction_123 +happyReduction_123 happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> happyIn51 - (flip (:) happy_var_1 happy_var_2 + ((:[]) happy_var_1 + )} + +happyReduce_124 = happySpecReduce_3 46# happyReduction_124 +happyReduction_124 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + happyIn51 + ((:) happy_var_1 happy_var_3 )}} -happyReduce_124 = happySpecReduce_0 48# happyReduction_124 -happyReduction_124 = happyIn52 +happyReduce_125 = happySpecReduce_0 47# happyReduction_125 +happyReduction_125 = happyIn52 ([] ) -happyReduce_125 = happySpecReduce_2 48# happyReduction_125 -happyReduction_125 happy_x_2 - happy_x_1 - = case happyOut52 happy_x_1 of { happy_var_1 -> - case happyOut5 happy_x_2 of { happy_var_2 -> +happyReduce_126 = happySpecReduce_1 47# happyReduction_126 +happyReduction_126 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> happyIn52 + ((:[]) happy_var_1 + )} + +happyReduce_127 = happySpecReduce_3 47# happyReduction_127 +happyReduction_127 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + happyIn52 + ((:) happy_var_1 happy_var_3 + )}} + +happyReduce_128 = happySpecReduce_0 48# happyReduction_128 +happyReduction_128 = happyIn53 + ([] + ) + +happyReduce_129 = happySpecReduce_2 48# happyReduction_129 +happyReduction_129 happy_x_2 + happy_x_1 + = case happyOut53 happy_x_1 of { happy_var_1 -> + case happyOut33 happy_x_2 of { happy_var_2 -> + happyIn53 (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_126 = happySpecReduce_0 49# happyReduction_126 -happyReduction_126 = happyIn53 +happyReduce_130 = happySpecReduce_0 49# happyReduction_130 +happyReduction_130 = happyIn54 ([] ) -happyReduce_127 = happySpecReduce_1 49# happyReduction_127 -happyReduction_127 happy_x_1 - = case happyOut37 happy_x_1 of { happy_var_1 -> - happyIn53 - ((:[]) happy_var_1 - )} - -happyReduce_128 = happySpecReduce_3 49# happyReduction_128 -happyReduction_128 happy_x_3 - happy_x_2 +happyReduce_131 = happySpecReduce_2 49# happyReduction_131 +happyReduction_131 happy_x_2 happy_x_1 - = case happyOut37 happy_x_1 of { happy_var_1 -> - case happyOut53 happy_x_3 of { happy_var_3 -> - happyIn53 - ((:) happy_var_1 happy_var_3 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_2 of { happy_var_2 -> + happyIn54 + (flip (:) happy_var_1 happy_var_2 )}} -happyReduce_129 = happySpecReduce_0 50# happyReduction_129 -happyReduction_129 = happyIn54 - ([] - ) - -happyReduce_130 = happySpecReduce_1 50# happyReduction_130 -happyReduction_130 happy_x_1 - = case happyOut41 happy_x_1 of { happy_var_1 -> - happyIn54 - ((:[]) happy_var_1 - )} - -happyReduce_131 = happySpecReduce_3 50# happyReduction_131 -happyReduction_131 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut41 happy_x_1 of { happy_var_1 -> - case happyOut54 happy_x_3 of { happy_var_3 -> - happyIn54 - ((:) happy_var_1 happy_var_3 - )}} - -happyReduce_132 = happySpecReduce_0 51# happyReduction_132 +happyReduce_132 = happySpecReduce_0 50# happyReduction_132 happyReduction_132 = happyIn55 ([] ) -happyReduce_133 = happySpecReduce_2 51# happyReduction_133 -happyReduction_133 happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> +happyReduce_133 = happySpecReduce_1 50# happyReduction_133 +happyReduction_133 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> happyIn55 - (flip (:) happy_var_1 happy_var_2 + ((:[]) happy_var_1 + )} + +happyReduce_134 = happySpecReduce_3 50# happyReduction_134 +happyReduction_134 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn55 + ((:) happy_var_1 happy_var_3 )}} -happyReduce_134 = happySpecReduce_0 52# happyReduction_134 -happyReduction_134 = happyIn56 +happyReduce_135 = happySpecReduce_0 51# happyReduction_135 +happyReduction_135 = happyIn56 ([] ) -happyReduce_135 = happySpecReduce_1 52# happyReduction_135 -happyReduction_135 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> +happyReduce_136 = happySpecReduce_1 51# happyReduction_136 +happyReduction_136 happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> happyIn56 ((:[]) happy_var_1 )} -happyReduce_136 = happySpecReduce_3 52# happyReduction_136 -happyReduction_136 happy_x_3 +happyReduce_137 = happySpecReduce_3 51# happyReduction_137 +happyReduction_137 happy_x_3 happy_x_2 happy_x_1 - = case happyOut4 happy_x_1 of { happy_var_1 -> + = case happyOut43 happy_x_1 of { happy_var_1 -> case happyOut56 happy_x_3 of { happy_var_3 -> happyIn56 ((:) happy_var_1 happy_var_3 )}} +happyReduce_138 = happySpecReduce_0 52# happyReduction_138 +happyReduction_138 = happyIn57 + ([] + ) + +happyReduce_139 = happySpecReduce_2 52# happyReduction_139 +happyReduction_139 happy_x_2 + happy_x_1 + = case happyOut57 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn57 + (flip (:) happy_var_1 happy_var_2 + )}} + +happyReduce_140 = happySpecReduce_0 53# happyReduction_140 +happyReduction_140 = happyIn58 + ([] + ) + +happyReduce_141 = happySpecReduce_1 53# happyReduction_141 +happyReduction_141 happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + happyIn58 + ((:[]) happy_var_1 + )} + +happyReduce_142 = happySpecReduce_3 53# happyReduction_142 +happyReduction_142 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut58 happy_x_3 of { happy_var_3 -> + happyIn58 + ((:) happy_var_1 happy_var_3 + )}} + happyNewToken action sts stk [] = happyDoAction 53# (error "reading EOF!") action sts stk [] @@ -1741,17 +1801,26 @@ happyNewToken action sts stk (tk:tks) = PT _ (TL happy_dollar_dollar) -> cont 50#; PT _ (TI happy_dollar_dollar) -> cont 51#; _ -> cont 52#; - _ -> happyError tks + _ -> happyError' (tk:tks) } -happyThen :: Err a -> (a -> Err b) -> Err b +happyError_ tk tks = happyError' (tk:tks) + +happyThen :: () => Err a -> (a -> Err b) -> Err b happyThen = (thenM) -happyReturn :: a -> Err a +happyReturn :: () => a -> Err a happyReturn = (returnM) happyThen1 m k tks = (thenM) m (\a -> k a tks) +happyReturn1 :: () => a -> b -> Err a happyReturn1 = \a tks -> (returnM) a +happyError' :: () => [Token] -> Err a +happyError' = happyError -pCanon tks = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut7 x)) +pCanon tks = happySomeParser where + happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut8 x)) + +pLine tks = happySomeParser where + happySomeParser = happyThen (happyParse 1# tks) (\x -> happyReturn (happyOut9 x)) happySeq = happyDontSeq @@ -1767,7 +1836,7 @@ happyError ts = myLexer = tokens {-# LINE 1 "GenericTemplate.hs" #-} --- $Id: ParGFC.hs,v 1.9 2005/04/21 16:21:27 bringert Exp $ +-- $Id: ParGFC.hs,v 1.10 2005/05/27 21:05:17 aarne Exp $ @@ -1835,9 +1904,13 @@ happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll ----------------------------------------------------------------------------- -- Accepting the parse -happyAccept j tk st sts (HappyStk ans _) = (happyTcHack j - (happyTcHack st)) - (happyReturn1 ans) +-- If the current token is 0#, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans) ----------------------------------------------------------------------------- -- Arrays only: do the next action @@ -1910,7 +1983,7 @@ data HappyAddr = HappyA# Addr# ----------------------------------------------------------------------------- -- HappyState data type (not arrays) -{-# LINE 165 "GenericTemplate.hs" #-} +{-# LINE 169 "GenericTemplate.hs" #-} ----------------------------------------------------------------------------- @@ -1990,8 +2063,7 @@ happyGoto nt j tk st = -- parse error if we are in recovery and we fail again happyFail 0# tk old_st _ stk = -- trace "failing" $ - happyError - + happyError_ tk {- We don't need state discarding for our restricted implementation of "error". In fact, it can cause some bogus parses, so I've disabled it diff --git a/src/GF/Canon/PrintGFC.hs b/src/GF/Canon/PrintGFC.hs index e2c5c44a4..6a14c1fb5 100644 --- a/src/GF/Canon/PrintGFC.hs +++ b/src/GF/Canon/PrintGFC.hs @@ -19,7 +19,7 @@ doc = (:) render :: Doc -> String render d = rend 0 (map ($ "") $ d []) "" where rend i ss = case ss of - "NEW" :ts -> realnew . rend i ts --H + "*NEW" :ts -> realnew . rend i ts --H "<" :ts -> showString "<" . rend i ts --H "$" :ts -> showString "$" . rend i ts --H "?" :ts -> showString "?" . rend i ts --H @@ -99,10 +99,17 @@ instance Print Canon where MGr ids id modules -> prPrec i 0 (concatD [doc (showString "grammar") , prt 0 ids , doc (showString "of") , prt 0 id , doc (showString ";") , prt 0 modules]) Gr modules -> prPrec i 0 (concatD [prt 0 modules]) +instance Print Line where + prt i e = case e of + LMulti ids id -> prPrec i 0 (concatD [doc (showString "grammar") , prt 0 ids , doc (showString "of") , prt 0 id , doc (showString ";") , doc (showString "*NEW")]) + LHeader modtype extend open -> prPrec i 0 (concatD [prt 0 modtype , doc (showString "=") , prt 0 extend , prt 0 open , doc (showString "{"), doc (showString "*NEW")]) + LFlag flag -> prPrec i 0 (concatD [prt 0 flag , doc (showString ";") , doc (showString "*NEW")]) + LDef def -> prPrec i 0 (concatD [prt 0 def , doc (showString ";") , doc (showString "*NEW")]) + LEnd -> prPrec i 0 (concatD [doc (showString "}")]) instance Print Module where prt i e = case e of - Mod modtype extend open flags defs -> prPrec i 0 (concatD [prt 0 modtype , doc (showString "=") , prt 0 extend , prt 0 open , doc (showString "{") , prt 0 flags , prt 0 defs , doc (showString "}")]) + Mod modtype extend open flags defs -> prPrec i 0 (concatD [prt 0 modtype , doc (showString "=") , prt 0 extend , prt 0 open , doc (showString "{") , doc (showString "*NEW") , prt 0 flags , prt 0 defs , doc (showString "}")]) prtList es = case es of [] -> (concatD []) @@ -134,7 +141,7 @@ instance Print Flag where prtList es = case es of [] -> (concatD []) - x:xs -> (concatD [prt 0 x , doc (showString ";") , prt 0 xs]) + x:xs -> (concatD [prt 0 x , doc (showString ";") , doc (showString "*NEW") , prt 0 xs]) instance Print Def where prt i e = case e of @@ -149,7 +156,7 @@ instance Print Def where prtList es = case es of [] -> (concatD []) - x:xs -> (concatD [prt 0 x , doc (showString ";"), doc (showString "NEW") , prt 0 xs]) -- H + x:xs -> (concatD [prt 0 x , doc (showString ";"), doc (showString "*NEW") , prt 0 xs]) -- H instance Print ParDef where prt i e = case e of diff --git a/src/GF/Compile/GrammarToCanon.hs b/src/GF/Compile/GrammarToCanon.hs index a87b1f7e1..4a07de157 100644 --- a/src/GF/Compile/GrammarToCanon.hs +++ b/src/GF/Compile/GrammarToCanon.hs @@ -5,9 +5,9 @@ -- Stability : (stable) -- Portability : (portable) -- --- > CVS $Date: 2005/04/21 16:21:38 $ --- > CVS $Author: bringert $ --- > CVS $Revision: 1.17 $ +-- > CVS $Date: 2005/05/27 21:05:17 $ +-- > CVS $Author: aarne $ +-- > CVS $Revision: 1.18 $ -- -- Code generator from optimized GF source code to GFC. ----------------------------------------------------------------------------- @@ -69,8 +69,11 @@ redModInfo (c,info) = do mt = mt0 ---- if isIncompl then MTResource else mt0 defss <- mapM (redInfo a) $ tree2list $ js - defs <- return $ sorted2tree $ concat defss -- sorted, but reduced - return $ ModMod $ Module mt MSComplete flags e os defs + let defs0 = concat defss + let lgh = length defs0 + defs <- return $ sorted2tree $ defs0 -- sorted, but reduced + let flags' = G.Flg (identC "modulesize") (identC ("n"++show lgh)) : flags + return $ ModMod $ Module mt MSComplete flags' e os defs return (c',info') where redExtOpen m = do