diff --git a/Codec/TPTP/Base.hs b/Codec/TPTP/Base.hs --- a/Codec/TPTP/Base.hs +++ b/Codec/TPTP/Base.hs @@ -20,6 +20,7 @@ import Data.String import Data.Monoid hiding(All) import Control.Monad.Identity +import Control.Monad.State import Data.Function -- Should be in the standard library @@ -30,8 +31,6 @@ deriving instance Data a => Data (Identity a) deriving instance Typeable1 Identity - - -- * Basic undecorated formulae and terms -- | Basic (undecorated) first-order formulae @@ -39,7 +38,41 @@ -- | Basic (undecorated) terms type Term = T Identity + +-- * Formulae and terms decoreated with state + +-- | First-order formulae decorated with state +type FormulaST s = F (State s) +-- | Terms decorated with state +type TermST s = T (State s) + +-- | First-order formulae decorated with comments +type FormulaC = FormulaST [String] + +-- | Terms decorated with comments +type TermC = TermST [String] + +-- | Forget comments in formulae decoreated with comments +forgetFC :: FormulaC -> Formula +forgetFC (F f) = F . return $ + case evalState f [] of + BinOp f1 op f2 -> BinOp (forgetFC f1) op (forgetFC f2) + InfixPred t1 pred t2 -> InfixPred (forgetTC t1) pred (forgetTC t1) + PredApp aw ts -> PredApp aw (fmap forgetTC ts) + Quant quant vs f -> Quant quant vs (forgetFC f) + (:~:) f -> (:~:) (forgetFC f) + +-- | Forget comments in terms decoreated with comments +forgetTC :: TermC -> Term +forgetTC (T t) = T . return $ + case evalState t [] of + Var v -> Var v + NumberLitTerm d -> NumberLitTerm d + DistinctObjectTerm s -> DistinctObjectTerm s + FunApp aw ts -> FunApp aw (fmap forgetTC ts) + + -- | Equivalence -- -- Don't let the type context of these wrapper function confuse you :) -- the important special case is just: @@ -225,7 +258,8 @@ -- * Formula Metadata -- | A line of a TPTP file: Annotated formula, comment or include statement. -data TPTP_Input = +type TPTP_Input = TPTP_Input_ Identity +{- -- | Annotated formulae AFormula { name :: AtomicWord @@ -237,9 +271,38 @@ | Include FilePath [AtomicWord] deriving (Eq,Ord,Show,Read,Data,Typeable) - - +-} + +-- | A line of a TPTP file: Annotated formula (with the comment string embbeded in the State monad ), comment or include statement +type TPTP_Input_C = TPTP_Input_ (State [String]) + +-- | Forget comments in a line of a TPTP file decoreated with comments +forgetTIC :: TPTP_Input_C -> TPTP_Input +forgetTIC tic@(AFormula {}) = tic { formula = forgetFC (formula tic) } +forgetTIC (Comment s) = Comment s +forgetTIC (Include p aws) = Include p aws + +-- | generalized TPTP_Input +data TPTP_Input_ c = + -- | Annotated formulae + AFormula { + name :: AtomicWord + , role :: Role + , formula :: F c + , annotations :: Annotations + } + | Comment String + | Include FilePath [AtomicWord] + +deriving instance Eq (c (Formula0 (T c) (F c))) => Eq (TPTP_Input_ c) +deriving instance Ord (c (Formula0 (T c) (F c))) => Ord (TPTP_Input_ c) +deriving instance Show (c (Formula0 (T c) (F c))) => Show (TPTP_Input_ c) +deriving instance Read (c (Formula0 (T c) (F c))) => Read (TPTP_Input_ c) +deriving instance (Typeable1 c, Data (c (Formula0 (T c) (F c)))) => Data (TPTP_Input_ c) +instance Typeable1 c => Typeable (TPTP_Input_ c) where + typeOf ti = mkTyCon "TPTP_Input_" `mkTyConApp` [typeOf1 (runF $ formula ti)] + -- hopefully (runF $ formula ti) never gets evaluated -- | Annotations about the formulas origin data Annotations = NoAnnotations | Annotations GTerm UsefulInfo @@ -249,7 +312,7 @@ data UsefulInfo = NoUsefulInfo | UsefulInfo [GTerm] deriving (Eq,Ord,Show,Read,Data,Typeable) --- | Formula roles +-- | Formula roles -- why isn't this newtype?? data Role = Role { unrole :: String } deriving (Eq,Ord,Show,Read,Data,Typeable) diff --git a/Codec/TPTP/Import.hs b/Codec/TPTP/Import.hs --- a/Codec/TPTP/Import.hs +++ b/Codec/TPTP/Import.hs @@ -1,16 +1,24 @@ module Codec.TPTP.Import(parse,parseFile + ,parseWithComment,parseWithCommentFile ,Token(..)) where - + import Lexer import Parser +import ParserC import Codec.TPTP.Base - - + parse :: String -> [TPTP_Input] parse = parseTPTP . map snd . alexScanTokens - - + parseFile :: FilePath -> IO [TPTP_Input] parseFile x = parse `fmap` readFile x + + +parseWithComment :: String -> [TPTP_Input_C] +parseWithComment = parseTPTPwithComment . map snd . alexScanTokens + +parseWithCommentFile :: FilePath -> IO [TPTP_Input_C] +parseWithCommentFile x = parseWithComment `fmap` readFile x + diff --git a/Codec/TPTP/Pretty.hs b/Codec/TPTP/Pretty.hs --- a/Codec/TPTP/Pretty.hs +++ b/Codec/TPTP/Pretty.hs @@ -24,26 +24,26 @@ fsym = yellow . pretty --wtext :: String -> Doc ---wtext = white.text - +--wtext = white . text + prettyargs :: forall a. (Pretty a) => [a] -> Doc --prettyargs = encloseSep (wtext "(") (wtext ")") (wtext ",") . fmap pretty prettyargs = tupled . fmap pretty -- prettyargs [] = white $ text "()" -- prettyargs (x:xs) = --- let pxs = fmap ((white (text ",") <+>) . pretty) xs in +-- let pxs = fmap ((white (text ",") <+>) . pretty) xs in --- align (fillSep $ [ white (text "(") <+> pretty x ] --- ++ pxs --- ++ [ white (text ")") ] ) - - +-- align (fillSep $ [ white (text "(") <+> pretty x ] +-- ++ pxs +-- ++ [ white (text ")") ] ) + + -- | Carries information about the enclosing operation (for the purpose of printing stuff without parentheses if possible). data WithEnclosing a = WithEnclosing Enclosing a - + data Enclosing = EnclBinOp BinOp | EnclQuant | EnclNeg | EnclInfixPred InfixPred | EnclNothing deriving (Eq,Ord,Show,Data,Typeable,Read) - + unaryEncl :: Enclosing -> Bool unaryEncl EnclNeg = True unaryEncl EnclQuant = True @@ -56,16 +56,16 @@ ((EnclBinOp (:&:)),(EnclBinOp (:&:))) -> False ((EnclBinOp (:|:)),(EnclBinOp (:|:))) -> False ((EnclBinOp (:<~>:)),(EnclBinOp (:<~>:))) -> False - + -- chains of quantifiers/negation don't need parentheses - _ - | unaryEncl inner, unaryEncl outer + _ + | unaryEncl inner, unaryEncl outer -> False - + _ -> prec inner <= prec outer where prec :: Enclosing -> Int - prec x = case x of + prec x = case x of (EnclInfixPred _) -> 60 (EnclNeg) -> 50 (EnclQuant) -> 50 @@ -82,10 +82,10 @@ maybeParens :: Enclosing -> Enclosing -> Doc -> Doc maybeParens inner outer | needsParens inner outer = parens -maybeParens _ _ = id - +maybeParens _ _ = id + instance Pretty TPTP_Input where - pretty AFormula{..} + pretty AFormula{..} = (text) "Formula " <+> (dullwhite.text) "name:" vsep @@ -95,55 +95,55 @@ , pretty annotations ,empty ] - + pretty (Comment str) = magenta . string $ str - - pretty (Include f sel) = text "include" <> parens (squotes (text f) <> (case sel of { [] -> empty; _ -> comma <+> sep (punctuate comma (fmap pretty sel)) } )) - - - prettyList = foldr (\x xs -> pretty x <$> xs) empty - + + pretty (Include f sel) = text "include" <> parens (squotes (text f) <> (case sel of { [] -> empty; _ -> comma <+> sep (punctuate comma (fmap pretty sel)) } )) + + + prettyList = foldr (\x xs -> pretty x <$> xs) empty + instance Pretty Quant where pretty All = oper "∀" pretty Exists = oper "∃" - + instance (Pretty (WithEnclosing t), Pretty (WithEnclosing f)) => Pretty ((WithEnclosing (Formula0 t f))) where - pretty (WithEnclosing enclosing formu) = - let + pretty (WithEnclosing enclosing formu) = + let newEnclosing = case formu of - Quant _ _ _ -> EnclQuant + Quant _ _ _ -> EnclQuant PredApp _ _ -> EnclNothing -- arguments are comma-seperated, so they don't need any parens (:~:) _ -> EnclNeg BinOp _ op _ -> EnclBinOp op InfixPred _ op _ -> EnclInfixPred op - + wne = WithEnclosing newEnclosing - + in maybeParens newEnclosing enclosing $ - + case formu of Quant q vars f -> - pretty q - <+> brackets (hsep (punctuate comma (fmap pretty vars))) - <> dot + pretty q + <+> brackets (hsep (punctuate comma (fmap pretty vars))) + <> dot pretty (wne f) (:~:) f -> oper "¬" <+> pretty (wne f) - + PredApp p [] -> psym p PredApp p args -> psym p <> prettyargs (fmap wne args) - + BinOp f1 op f2 -> align $ sep [indent 0 $ pretty (wne f1), pretty op, indent 0 $ pretty (wne f2)] - + InfixPred f1 op f2 -> align $ sep [indent 0 $ pretty (wne f1), pretty op, indent 0 $ pretty (wne f2)] - + instance Pretty BinOp where pretty x = case x of (:<=>:) -> oper "⇔" @@ -154,45 +154,45 @@ (:~&:) -> oper "NAND" (:~|:) -> oper "NOR" (:<~>:) -> oper "XOR" - + instance Pretty InfixPred where pretty x = case x of (:=:) -> oper "=" (:!=:) -> oper "≠" - + instance (Pretty (WithEnclosing t)) => Pretty (WithEnclosing (Term0 t)) where - pretty (WithEnclosing _ x) = - case x of + pretty (WithEnclosing _ x) = + case x of Var s -> pretty s NumberLitTerm d -> text (show d) DistinctObjectTerm s -> cyan (dquotes (text s)) FunApp f [] -> fsym f FunApp f args -> fsym f <> prettyargs (fmap (WithEnclosing EnclNothing) args) - - + + instance Pretty (Formula0 Term Formula) where pretty = pretty . WithEnclosing EnclNothing . F . Identity - + instance Pretty (Term0 Term) where pretty = pretty . WithEnclosing EnclNothing . T . Identity - + instance Pretty (WithEnclosing Formula) where - pretty (WithEnclosing x (F (Identity y))) = pretty (WithEnclosing x y) - + pretty (WithEnclosing x (F (Identity y))) = pretty (WithEnclosing x y) + instance Pretty (WithEnclosing Term) where - pretty (WithEnclosing x (T (Identity y))) = pretty (WithEnclosing x y) - + pretty (WithEnclosing x (T (Identity y))) = pretty (WithEnclosing x y) + deriving instance Pretty Formula deriving instance Pretty Term deriving instance Pretty a => Pretty (Identity a) - + -- instance (Pretty f, Pretty t) => Pretty (Formula0 t f) where -- pretty = pretty . WithEnclosing "" - + -- instance (Pretty t) => Pretty (Term0 t) where -- pretty = pretty . WithEnclosing "" - + prettySimple :: Pretty a => a -> String prettySimple x = displayS (renderPretty 0.9 80 (pretty x)) "" @@ -216,7 +216,7 @@ pretty (GVar x) = pretty x instance Pretty AtomicWord where - pretty (AtomicWord x) = (if isLowerWord x then text else squotes.text) x + pretty (AtomicWord x) = (if isLowerWord x then text else squotes.text) x instance Pretty GTerm where pretty (GTerm x) = pretty x @@ -224,8 +224,8 @@ pretty (GList xs) = let f = oper in f "[" <+> (fillSep . punctuate comma . fmap pretty) xs <+> f "]" - - -instance Pretty V where + + +instance Pretty V where pretty (V x) = blue . text $ x diff --git a/Parser.y b/Parser.y --- a/Parser.y +++ b/Parser.y @@ -97,38 +97,38 @@ formula_role : lower_word_ { Role $1 } -fof_formula :: {Formula} +fof_formula :: {F c} fof_formula : binary_formula { $1 } | unitary_formula { $1 } -binary_formula :: {Formula} +binary_formula :: {F c} binary_formula : nonassoc_binary {$1} | assoc_binary {$1} -nonassoc_binary :: {Formula} +nonassoc_binary :: {F c} nonassoc_binary : unitary_formula binary_connective unitary_formula { $2 $1 $3 } -assoc_binary :: {Formula} +assoc_binary :: {F c} assoc_binary : or_formula { $1 } | and_formula { $1 } -or_formula :: {Formula} +or_formula :: {F c} or_formula : unitary_formula vline unitary_formula more_or_formula { foldl (.|.) ($1 .|. $3) $4 } -more_or_formula :: {[Formula]} +more_or_formula :: {[F c]} more_or_formula : {[]} | vline unitary_formula more_or_formula { $2 : $3 } -and_formula :: {Formula} +and_formula :: {F c} and_formula : unitary_formula ampersand unitary_formula more_and_formula { foldl (.&.) ($1 .&. $3) $4 } -more_and_formula :: {[Formula]} +more_and_formula :: {[F c]} more_and_formula : {[]} | ampersand unitary_formula more_and_formula { $2 : $3 } @@ -138,15 +138,15 @@ | atomic_formula {$1} | lp fof_formula rp {$2} -quantified_formula :: {Formula} -quantified_formula : quantifier lbra variable_list rbra colon unitary_formula - { $1 $3 $6 } +quantified_formula :: {F c} +quantified_formula : quantifier lbra variable_list rbra colon unitary_formula + { $1 $3 $6 } variable_list :: {[V]} variable_list : variable { [$1] } | variable comma variable_list { $1 : $3 } -unary_formula :: {Formula} +unary_formula :: {F c} unary_formula : unary_connective unitary_formula { $1 $2 } | fol_infix_unary { $1 } @@ -157,16 +157,16 @@ -- cnf_formula : assoc_binary {$1} -- | lp assoc_binary rp {$2} -cnf_formula :: {Formula} +cnf_formula :: {F c} cnf_formula : lp disjunction rp { $2 } | disjunction { $1 } -disjunction :: {Formula} +disjunction :: {F c} disjunction : literal more_disjunction { foldl (.|.) $1 $2 } -more_disjunction :: {[Formula]} +more_disjunction :: {[F c]} more_disjunction : {[]} | vline literal more_disjunction { $2 : $3 } @@ -175,7 +175,7 @@ | tilde atomic_formula { (.~.) $2} | fol_infix_unary {$1} -fol_infix_unary :: {Formula} +fol_infix_unary :: {F c} fol_infix_unary : term infix_inequality term { $2 $1 $3 } quantifier :: {[V] -> Formula -> Formula} @@ -200,7 +200,7 @@ -- defined_type :== $oType | $o | $iType | $i | $tType | $real | $int -- system_type :== atomic_system_word -atomic_formula :: {Formula} +atomic_formula :: {F c} atomic_formula : plain_atomic_formula {$1} | defined_atomic_formula {$1} | system_atomic_formula {$1} @@ -213,11 +213,11 @@ -- proposition :== predicate -- predicate :== atomic_word -defined_atomic_formula :: {Formula} +defined_atomic_formula :: {F c} defined_atomic_formula : defined_plain_formula {$1} | defined_infix_formula {$1} -defined_plain_formula :: {Formula} +defined_plain_formula :: {F c} defined_plain_formula : defined_plain_term {fApp2pApp $1} --defined_plain_formula :== defined_prop | defined_pred lp arguments rp @@ -227,10 +227,10 @@ --defined_pred :== $equal -defined_infix_formula :: {Formula} +defined_infix_formula :: {F c} defined_infix_formula : term defined_infix_pred term { $2 $1 $3 } -defined_infix_pred :: { Term -> Term -> Formula } +defined_infix_pred :: { T c -> T c -> F c } defined_infix_pred : infix_equality { $1 } infix_equality :: { Term -> Term -> Formula } @@ -298,7 +298,7 @@ variable :: {V} variable : upper_word {V $1} -arguments :: {[Term]} +arguments :: {[T c]} arguments : term {[$1]} | term comma arguments { $1 : $3 } diff --git a/ParserC.y b/ParserC.y new file mode 100644 --- /dev/null +++ b/ParserC.y @@ -0,0 +1,509 @@ +{ +module ParserC where + +import Data.Char +import Data.Data +import Control.Monad +import Data.List as L +import Lexer +import Data.Set as S +import Codec.TPTP.Base +import System.IO +import System.IO.Unsafe +import Control.Monad.Identity +import Control.Monad.State +} + +%name parseTPTPwithComment +%tokentype { Token } +%error { + + ((\xs -> case xs of + xs -> error ("Parse error, pos: "++show (take 25 xs)))) + } + + +%token + tok_lp { LP } + tok_rp { RP } + tok_lbra { Lbrack } + tok_rbra { Rbrack } + tok_comma { Comma } + tok_dot { Dot } + tok_star { Star } + tok_plus { Plus } + tok_rangle { Rangle } + tok_colon { Oper ":" } + + tok_iff { Oper "<=>"} + tok_implies { Oper "=>"} + tok_xor { Oper "<~>"} + tok_nor { Oper "~|"} + tok_nand { Oper "~&"} + tok_impliedby { Oper "<=" } + tok_equals { Oper "=" } + tok_nequals { Oper "!=" } + + tok_exclam { Oper "!" } + tok_question { Oper "?" } + tok_ampersand { Oper "&" } + tok_vline { Oper "|" } + tok_tilde { Oper "~" } + + tok_fof { LowerWord "fof" } + tok_cnf { LowerWord "cnf" } + tok_include_ { LowerWord "include" } + + tok_single_quoted { SingleQuoted $$ } + tok_distinct_object { DoubleQuoted $$ } + tok_dollar_word { DollarWord $$ } + tok_dollar_dollar_word { DollarDollarWord $$ } + tok_upper_word { UpperWord $$ } + tok_lower_word { LowerWord $$ } + tok_signed_integer { SignedInt $$ } + tok_unsigned_integer { UnsignedInt $$ } + tok_real { Real $$ } + + comment { CommentToken $$ } + + +%% + +TPTP_file :: {[TPTP_Input_ c]} +TPTP_file : {[]} | TPTP_input TPTP_file {$1 : $2} + +TPTP_input :: {TPTP_Input_ c} +TPTP_input : annotated_formula {$1} + | include { $1 } + | comment { Comment $1 } + +annotated_formula :: {TPTP_Input_ c} +annotated_formula : fof_annotated {$1} + | cnf_annotated {$1} + +fof_annotated :: {TPTP_Input_ c} +fof_annotated : fof lp name comma formula_role comma fof_formula annotations rp dot + { AFormula $3 $5 $7 $8 } + +cnf_annotated :: {TPTP_Input} +cnf_annotated : cnf lp name comma formula_role comma cnf_formula annotations rp dot + { AFormula $3 $5 (univquant_free_vars $7) $8 } + + +annotations :: { Annotations } +annotations : comma source optional_info { Annotations $2 $3 } + | { NoAnnotations } + +formula_role :: {Role} +formula_role : lower_word_ { Role $1 } + + +fof_formula :: {F c} +fof_formula : binary_formula { $1 } + | unitary_formula { $1 } + +binary_formula :: {F c} +binary_formula : nonassoc_binary {$1} + | assoc_binary {$1} + +nonassoc_binary :: {F c} +nonassoc_binary : unitary_formula binary_connective unitary_formula + { $2 $1 $3 } + + +assoc_binary :: {F c} +assoc_binary : or_formula { $1 } + | and_formula { $1 } + + +or_formula :: {F c} +or_formula : unitary_formula vline unitary_formula more_or_formula + { foldl (.|.) ($1 .|. $3) $4 } + +more_or_formula :: {[F c]} +more_or_formula : {[]} | vline unitary_formula more_or_formula + { $2 : $3 } + +and_formula :: {F c} +and_formula : unitary_formula ampersand unitary_formula more_and_formula + { foldl (.&.) ($1 .&. $3) $4 } + + +more_and_formula :: {[F c]} +more_and_formula : {[]} | ampersand unitary_formula more_and_formula + { $2 : $3 } + +unitary_formula :: {FormulaC} +unitary_formula : quantified_formula {$1} + | unary_formula {$1} + | atomic_formula {$1} + | lp fof_formula rp {$2} + +quantified_formula :: {F c} +quantified_formula : quantifier lbra variable_list rbra colon unitary_formula + { $1 $3 $6 `withComments` comm $5 } + +variable_list :: {[V]} +variable_list : variable { [$1] } + | variable comma variable_list { $1 : $3 } + +unary_formula :: {F c} +unary_formula : unary_connective unitary_formula { $1 $2 } + | fol_infix_unary { $1 } + + + + +-- cnf_formula :: {Formula} +-- cnf_formula : assoc_binary {$1} +-- | lp assoc_binary rp {$2} + +cnf_formula :: {F c} +cnf_formula : lp disjunction rp { $2 } + | disjunction { $1 } + + +disjunction :: {F c} +disjunction : literal more_disjunction + { foldl (.|.) $1 $2 } + +more_disjunction :: {[F c]} +more_disjunction : {[]} | vline literal more_disjunction + { $2 : $3 } + +literal :: {FormulaC} +literal : atomic_formula {$1} + | tilde atomic_formula { (.~.) $2} + | fol_infix_unary {$1} + +fol_infix_unary :: {F c} +fol_infix_unary : term infix_inequality term { $2 $1 $3 } + +quantifier :: {[V] -> FormulaC -> FormulaC} +quantifier : exclam { for_all } | question { exists } + +binary_connective :: {FormulaC -> FormulaC -> FormulaC} +binary_connective : iff { (.<=>.) } + | implies { (.=>.) } + | impliedby { (.<=.) } + | xor { (.<~>.) } + | nor { (.~|.) } + | nand { (.~&.) } + +--- assoc_connective : vline +--- | ampersand + +unary_connective :: {FormulaC -> FormulaC} +unary_connective : tilde { (.~.) } + +-- defined_type :== atomic_defined_word + +-- defined_type :== $oType | $o | $iType | $i | $tType | $real | $int +-- system_type :== atomic_system_word + +atomic_formula :: {F c} +atomic_formula : plain_atomic_formula {$1} + | defined_atomic_formula {$1} + | system_atomic_formula {$1} + + +plain_atomic_formula :: {F c} +plain_atomic_formula : plain_term { fApp2pApp $1 } + +-- plain_atomic_formula :== proposition | predicate lp arguments rp +-- proposition :== predicate +-- predicate :== atomic_word + +defined_atomic_formula :: {F c} +defined_atomic_formula : defined_plain_formula {$1} + | defined_infix_formula {$1} + +defined_plain_formula :: {F c} +defined_plain_formula : defined_plain_term {fApp2pApp $1} + +--defined_plain_formula :== defined_prop | defined_pred lp arguments rp +--defined_prop :== atomic_defined_word +--defined_prop :== $true | $false +--defined_pred :== atomic_defined_word +--defined_pred :== $equal + + +defined_infix_formula :: {F c} +defined_infix_formula : term defined_infix_pred term { $2 $1 $3 } + +defined_infix_pred :: { T c -> T c -> F c } +defined_infix_pred : infix_equality { $1 } + +infix_equality :: { TermC -> TermC -> FormulaC } +infix_equality : equals { (.=.) } + +infix_inequality :: { TermC -> TermC -> FormulaC } +infix_inequality : nequals { (.!=.) } + +system_atomic_formula :: {F c} +system_atomic_formula : system_term {fApp2pApp $1} + +term :: {TermC} +term : function_term {$1} + | variable {var $1} + +function_term :: {TermC} +function_term : plain_term {$1} + | defined_term {$1} + | system_term {$1} + +plain_term :: {TermC} +plain_term : constant {fApp $1 []} + | functor lp arguments rp {fApp $1 $3} + +constant :: {AtomicWord} +constant : functor {$1} + +functor :: {AtomicWord} +functor : atomic_word {$1} + +defined_term :: {TermC} +defined_term : defined_atom {$1} + | defined_atomic_term {$1} + + +defined_atom :: {TermC} +defined_atom : number {numberLitTerm $1} + | distinct_object {distinctObjectTerm (stripQuotes '"' $1)} + +defined_atomic_term :: {T c} +defined_atomic_term : defined_plain_term {$1} + +defined_plain_term :: {TermC} +defined_plain_term : defined_constant {fApp (AtomicWord $1) []} + | defined_functor lp arguments rp {fApp (AtomicWord $1) $3} + +defined_constant :: {String} +defined_constant : defined_functor {$1} +-- defined_constant :== + +defined_functor :: {String} +defined_functor : atomic_defined_word {$1} +-- defined_functor :== + +system_term :: {TermC} +system_term : system_constant {fApp (AtomicWord $1) []} + | system_functor lp arguments rp {fApp (AtomicWord $1) $3} + +system_constant :: {String} +system_constant : system_functor {$1} + +system_functor :: {String} +system_functor : atomic_system_word {$1} + +variable :: {V} +variable : upper_word {V $1} + +arguments :: {[T c]} +arguments : term {[$1]} + | term comma arguments { $1 : $3 } + +source :: {GTerm} +source : general_term {$1} + +-- source :== dag_source | internal_source | external_source | unknown + +-- dag_source :== name | inference_record + +-- inference_record :== inference lp inference_rule comma useful_info comma [parent_list ] rp +-- inference_rule :== atomic_word +-- parent_list :== parent_info | parent_info comma parent_list +-- parent_info :== source parent_details +-- parent_details :== :general_list | null +-- internal_source :== introduced lp intro_type optional_info rp +-- intro_type :== definition | axiom_of_choice | tautology | assumption +-- external_source :== file_source | theory | creator_source +-- file_source :== file lp file_name file_info rp +-- file_info :== comma name | null +-- theory :== theory lp theory_name optional_info rp +-- theory_name :== equality | ac +-- creator_source :== creator lp creator_name optional_info rp +-- creator_name :== atomic_word + +optional_info :: {UsefulInfo} +optional_info : comma useful_info {$2} | {NoUsefulInfo} + +useful_info :: { UsefulInfo } +useful_info : general_list {UsefulInfo $1} + +-- useful_info :== [] | [info_items ] +-- info_items :== info_item | info_item comma info_items +-- info_item :== formula_item | inference_item | general_function +-- formula_item :== description_item | iquote_item +-- description_item :== description lp atomic_word rp +-- iquote_item :== iquote lp atomic_word rp +-- inference_item :== inference_status | assumptions_record | refutation +-- inference_status :== status lp status_value rp | inference_info +-- status_value :== suc | unp | sap | esa | sat | fsa | thm | eqv | tac | wec | eth | tau | wtc | wth | cax | sca | tca | wca |cup | csp | ecs | csa | cth | ceq | unc | wcc | ect | fun | uns | wuc | wct | scc | uca | noc + +-- inference_info :== inference_rule lp atomic_word comma general_list rp +-- assumptions_record :== assumptions lp [name_list ] rp +-- refutation :== refutation lp file_source rp + +include :: {TPTP_Input} +include : include_ lp file_name formula_selection rp dot { Include $3 $4 } + +formula_selection :: {[AtomicWord]} +formula_selection : comma lbra name_list rbra { $3 } + | { [] } + +name_list :: {[AtomicWord]} +name_list : name {[$1]} + | name comma name_list { $1 : $3 } + + +general_term :: {GTerm} +general_term : general_data {GTerm $1} + | general_data colon general_term {ColonSep $1 $3} + | general_list {GList $1} + +general_data :: {GData} +general_data : atomic_word { GWord $1 } + | atomic_word lp general_terms rp { GApp $1 $3 } + | variable { GVar $1 } + | number { GNumber $1 } + | distinct_object { GDistinctObject (stripQuotes '"' $1) } + | formula_data { $1 } + +formula_data :: {GData} +formula_data : dollar_word lp fof_formula rp { GFormulaData $1 $3 } + -- too ambiguous | dollar_word lp cnf_formula rp { GFormulaData $1 $3 } + +general_list :: {[GTerm]} +general_list : lbra rbra {[]} + | lbra general_terms rbra {$2} + +general_terms :: {[GTerm]} +general_terms : general_term {[$1]} + | general_term comma general_terms {$1 : $3} + +name :: {AtomicWord} +name : atomic_word {$1} + | unsigned_integer {AtomicWord(show $1)} + +atomic_word :: {AtomicWord} +atomic_word : lower_word_ {AtomicWord $1} + | single_quoted{AtomicWord (stripQuotes '\'' $1)} + +atomic_defined_word :: {String} +atomic_defined_word : dollar_word{$1} + +atomic_system_word :: {String} +atomic_system_word : dollar_dollar_word{$1} + +number :: {Double} -- maybe keep track of the number type that was actually parsed +number : real {$1} | signed_integer {fromIntegral $1} | unsigned_integer {fromIntegral $1} + +file_name :: {String} +file_name : single_quoted {stripQuotes '\'' $1} + +lower_word_ :: {String} +lower_word_ : lower_word {$1} | fof {"fof"} | cnf {"cnf"} | include_ {"include"} -- "fof" is a perfectly cromulent lower_word, but it is interpreted as a "fof" token + +lp :: {Token} +lp : tok_lp comment_list { $1 } +rp :: {Token} +rp : tok_rp comment_list { $1 } +lbra :: {Token} +lbra : tok_lbra comment_list { $1 } +rbra :: {Token} +rbra : tok_rbra comment_list { $1 } +comma :: {Token} +comma : tok_comma comment_list { $1 } +dot :: {Token} +dot : tok_dot comment_list { $1 } +star :: {Token} +star : tok_star comment_list { $1 } +plus :: {Token} +plus : tok_plus comment_list { $1 } +rangle :: {Token} +rangle : tok_rangle comment_list { $1 } +colon :: {AToken} +colon : tok_colon comment_list { AToken $1 $2 } + +iff :: {Token} +iff : tok_iff comment_list { $1 } +implies :: {Token} +implies : tok_implies comment_list { $1 } +xor :: {Token} +xor : tok_xor comment_list { $1 } +nor :: {Token} +nor : tok_nor comment_list { $1 } +nand :: {Token} +nand : tok_nand comment_list { $1 } +impliedby :: {Token} +impliedby : tok_impliedby comment_list { $1 } +equals :: {Token} +equals : tok_equals comment_list { $1 } +nequals :: {Token} +nequals : tok_nequals comment_list { $1 } + +exclam :: {Token} +exclam : tok_exclam comment_list { $1 } +question :: {Token} +question : tok_question comment_list { $1 } +ampersand :: {Token} +ampersand : tok_ampersand comment_list { $1 } +vline :: {Token} +vline : tok_vline comment_list { $1 } +tilde :: {Token} +tilde : tok_tilde comment_list { $1 } + +fof :: {Token} +fof : tok_fof comment_list { $1 } +cnf :: {Token} +cnf : tok_cnf comment_list { $1 } +include_ :: {Token} +include_ : tok_include_ comment_list { $1 } + +single_quoted :: {String} +single_quoted : tok_single_quoted comment_list { $1 } +distinct_object :: {String} +distinct_object : tok_distinct_object comment_list { $1 } +dollar_word :: {String} +dollar_word : tok_dollar_word comment_list { $1 } +dollar_dollar_word :: {String} +dollar_dollar_word : tok_dollar_dollar_word comment_list { $1 } +upper_word :: {String} +upper_word : tok_upper_word comment_list { $1 } +lower_word :: {String} +lower_word : tok_lower_word comment_list { $1 } +signed_integer :: {Int} +signed_integer : tok_signed_integer comment_list { $1 } +unsigned_integer :: {Int} +unsigned_integer : tok_unsigned_integer comment_list { $1 } +real :: {Double} +real : tok_real comment_list { $1 } + +comment_list :: {[String]} +comment_list : {[]} | comment comment_list { $1 : $2 } + +{ +data AToken = AToken { tok :: Token, comm :: [String] } + +class Commented c where + withComments :: F c -> [String] -> F c + +instance Commented Identity where + withComments = const + +instance Commented (State [String]) where + withComments (F mf) s = F $ do { f <- mf; put s; return f } + + +stripQuotes which (x:xs) = go xs + where + go [x] = [] + go ('\\':'\\':xs) = '\\':go xs + go ('\\':which:xs) = which:go xs + go (x:xs) = x:go xs + +fApp2pApp (T mf) = F $ do FunApp x args <- mf + return $ PredApp x args +} + diff --git a/dist/build/Parser.hs b/dist/build/Parser.hs --- a/dist/build/Parser.hs +++ b/dist/build/Parser.hs @@ -65,52 +65,52 @@ happyOut10 :: (HappyAbsSyn ) -> (Role) happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut10 #-} -happyIn11 :: (Formula) -> (HappyAbsSyn ) +happyIn11 :: (F c) -> (HappyAbsSyn ) happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> (Formula) +happyOut11 :: (HappyAbsSyn ) -> (F c) happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut11 #-} -happyIn12 :: (Formula) -> (HappyAbsSyn ) +happyIn12 :: (F c) -> (HappyAbsSyn ) happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> (Formula) +happyOut12 :: (HappyAbsSyn ) -> (F c) happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut12 #-} -happyIn13 :: (Formula) -> (HappyAbsSyn ) +happyIn13 :: (F c) -> (HappyAbsSyn ) happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (Formula) +happyOut13 :: (HappyAbsSyn ) -> (F c) happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut13 #-} -happyIn14 :: (Formula) -> (HappyAbsSyn ) +happyIn14 :: (F c) -> (HappyAbsSyn ) happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> (Formula) +happyOut14 :: (HappyAbsSyn ) -> (F c) happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut14 #-} -happyIn15 :: (Formula) -> (HappyAbsSyn ) +happyIn15 :: (F c) -> (HappyAbsSyn ) happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (Formula) +happyOut15 :: (HappyAbsSyn ) -> (F c) happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut15 #-} -happyIn16 :: ([Formula]) -> (HappyAbsSyn ) +happyIn16 :: ([F c]) -> (HappyAbsSyn ) happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> ([Formula]) +happyOut16 :: (HappyAbsSyn ) -> ([F c]) happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut16 #-} -happyIn17 :: (Formula) -> (HappyAbsSyn ) +happyIn17 :: (F c) -> (HappyAbsSyn ) happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> (Formula) +happyOut17 :: (HappyAbsSyn ) -> (F c) happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut17 #-} -happyIn18 :: ([Formula]) -> (HappyAbsSyn ) +happyIn18 :: ([F c]) -> (HappyAbsSyn ) happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> ([Formula]) +happyOut18 :: (HappyAbsSyn ) -> ([F c]) happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut18 #-} happyIn19 :: (Formula) -> (HappyAbsSyn ) @@ -119,10 +119,10 @@ happyOut19 :: (HappyAbsSyn ) -> (Formula) happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut19 #-} -happyIn20 :: (Formula) -> (HappyAbsSyn ) +happyIn20 :: (F c) -> (HappyAbsSyn ) happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> (Formula) +happyOut20 :: (HappyAbsSyn ) -> (F c) happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut20 #-} happyIn21 :: ([V]) -> (HappyAbsSyn ) @@ -131,28 +131,28 @@ happyOut21 :: (HappyAbsSyn ) -> ([V]) happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut21 #-} -happyIn22 :: (Formula) -> (HappyAbsSyn ) +happyIn22 :: (F c) -> (HappyAbsSyn ) happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (Formula) +happyOut22 :: (HappyAbsSyn ) -> (F c) happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut22 #-} -happyIn23 :: (Formula) -> (HappyAbsSyn ) +happyIn23 :: (F c) -> (HappyAbsSyn ) happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> (Formula) +happyOut23 :: (HappyAbsSyn ) -> (F c) happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut23 #-} -happyIn24 :: (Formula) -> (HappyAbsSyn ) +happyIn24 :: (F c) -> (HappyAbsSyn ) happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn24 #-} -happyOut24 :: (HappyAbsSyn ) -> (Formula) +happyOut24 :: (HappyAbsSyn ) -> (F c) happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut24 #-} -happyIn25 :: ([Formula]) -> (HappyAbsSyn ) +happyIn25 :: ([F c]) -> (HappyAbsSyn ) happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn25 #-} -happyOut25 :: (HappyAbsSyn ) -> ([Formula]) +happyOut25 :: (HappyAbsSyn ) -> ([F c]) happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut25 #-} happyIn26 :: (Formula) -> (HappyAbsSyn ) @@ -161,10 +161,10 @@ happyOut26 :: (HappyAbsSyn ) -> (Formula) happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut26 #-} -happyIn27 :: (Formula) -> (HappyAbsSyn ) +happyIn27 :: (F c) -> (HappyAbsSyn ) happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn27 #-} -happyOut27 :: (HappyAbsSyn ) -> (Formula) +happyOut27 :: (HappyAbsSyn ) -> (F c) happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut27 #-} happyIn28 :: ([V] -> Formula -> Formula) -> (HappyAbsSyn ) @@ -185,10 +185,10 @@ happyOut30 :: (HappyAbsSyn ) -> (Formula -> Formula) happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut30 #-} -happyIn31 :: (Formula) -> (HappyAbsSyn ) +happyIn31 :: (F c) -> (HappyAbsSyn ) happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn31 #-} -happyOut31 :: (HappyAbsSyn ) -> (Formula) +happyOut31 :: (HappyAbsSyn ) -> (F c) happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut31 #-} happyIn32 :: (Formula) -> (HappyAbsSyn ) @@ -197,28 +197,28 @@ happyOut32 :: (HappyAbsSyn ) -> (Formula) happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut32 #-} -happyIn33 :: (Formula) -> (HappyAbsSyn ) +happyIn33 :: (F c) -> (HappyAbsSyn ) happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn33 #-} -happyOut33 :: (HappyAbsSyn ) -> (Formula) +happyOut33 :: (HappyAbsSyn ) -> (F c) happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut33 #-} -happyIn34 :: (Formula) -> (HappyAbsSyn ) +happyIn34 :: (F c) -> (HappyAbsSyn ) happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn34 #-} -happyOut34 :: (HappyAbsSyn ) -> (Formula) +happyOut34 :: (HappyAbsSyn ) -> (F c) happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut34 #-} -happyIn35 :: (Formula) -> (HappyAbsSyn ) +happyIn35 :: (F c) -> (HappyAbsSyn ) happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn35 #-} -happyOut35 :: (HappyAbsSyn ) -> (Formula) +happyOut35 :: (HappyAbsSyn ) -> (F c) happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut35 #-} -happyIn36 :: (Term -> Term -> Formula) -> (HappyAbsSyn ) +happyIn36 :: (T c -> T c -> F c) -> (HappyAbsSyn ) happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn36 #-} -happyOut36 :: (HappyAbsSyn ) -> (Term -> Term -> Formula) +happyOut36 :: (HappyAbsSyn ) -> (T c -> T c -> F c) happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut36 #-} happyIn37 :: (Term -> Term -> Formula) -> (HappyAbsSyn ) @@ -329,10 +329,10 @@ happyOut54 :: (HappyAbsSyn ) -> (V) happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut54 #-} -happyIn55 :: ([Term]) -> (HappyAbsSyn ) +happyIn55 :: ([T c]) -> (HappyAbsSyn ) happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn55 #-} -happyOut55 :: (HappyAbsSyn ) -> ([Term]) +happyOut55 :: (HappyAbsSyn ) -> ([T c]) happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut55 #-} happyIn56 :: (GTerm) -> (HappyAbsSyn ) @@ -1113,7 +1113,7 @@ case happyOut21 happy_x_3 of { happy_var_3 -> case happyOut19 happy_x_6 of { happy_var_6 -> happyIn20 - (happy_var_1 happy_var_3 happy_var_6 + (happy_var_1 happy_var_3 happy_var_6 ) `HappyStk` happyRest}}} happyReduce_31 = happySpecReduce_1 17# happyReduction_31 diff --git a/dist/build/ParserC.hs b/dist/build/ParserC.hs new file mode 100644 --- /dev/null +++ b/dist/build/ParserC.hs @@ -0,0 +1,2487 @@ +{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-} +{-# OPTIONS -fglasgow-exts -cpp #-} +module ParserC where + +import Data.Char +import Data.Data +import Control.Monad +import Data.List as L +import Lexer +import Data.Set as S +import Codec.TPTP.Base +import System.IO +import System.IO.Unsafe +import Control.Monad.Identity +import Control.Monad.State +import qualified Data.Array as Happy_Data_Array +import qualified GHC.Exts as Happy_GHC_Exts + +-- parser produced by Happy Version 1.18.5 + +newtype HappyAbsSyn = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: ([TPTP_Input_ c]) -> (HappyAbsSyn ) +happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn ) -> ([TPTP_Input_ c]) +happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: (TPTP_Input_ c) -> (HappyAbsSyn ) +happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn ) -> (TPTP_Input_ c) +happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: (TPTP_Input_ c) -> (HappyAbsSyn ) +happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn ) -> (TPTP_Input_ c) +happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: (TPTP_Input_ c) -> (HappyAbsSyn ) +happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn ) -> (TPTP_Input_ c) +happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: (TPTP_Input) -> (HappyAbsSyn ) +happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn ) -> (TPTP_Input) +happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: (Annotations) -> (HappyAbsSyn ) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (Annotations) +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: (Role) -> (HappyAbsSyn ) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> (Role) +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: (F c) -> (HappyAbsSyn ) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> (F c) +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: (F c) -> (HappyAbsSyn ) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> (F c) +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (F c) -> (HappyAbsSyn ) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (F c) +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: (F c) -> (HappyAbsSyn ) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> (F c) +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: (F c) -> (HappyAbsSyn ) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> (F c) +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: ([F c]) -> (HappyAbsSyn ) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> ([F c]) +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (F c) -> (HappyAbsSyn ) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (F c) +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: ([F c]) -> (HappyAbsSyn ) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> ([F c]) +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: (FormulaC) -> (HappyAbsSyn ) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> (FormulaC) +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (F c) -> (HappyAbsSyn ) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (F c) +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: ([V]) -> (HappyAbsSyn ) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> ([V]) +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: (F c) -> (HappyAbsSyn ) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> (F c) +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: (F c) -> (HappyAbsSyn ) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> (F c) +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: (F c) -> (HappyAbsSyn ) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> (F c) +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: ([F c]) -> (HappyAbsSyn ) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> ([F c]) +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: (FormulaC) -> (HappyAbsSyn ) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> (FormulaC) +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (F c) -> (HappyAbsSyn ) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (F c) +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: ([V] -> FormulaC -> FormulaC) -> (HappyAbsSyn ) +happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> ([V] -> FormulaC -> FormulaC) +happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: (FormulaC -> FormulaC -> FormulaC) -> (HappyAbsSyn ) +happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> (FormulaC -> FormulaC -> FormulaC) +happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: (FormulaC -> FormulaC) -> (HappyAbsSyn ) +happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> (FormulaC -> FormulaC) +happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: (F c) -> (HappyAbsSyn ) +happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> (F c) +happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: (F c) -> (HappyAbsSyn ) +happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> (F c) +happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut32 #-} +happyIn33 :: (F c) -> (HappyAbsSyn ) +happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn33 #-} +happyOut33 :: (HappyAbsSyn ) -> (F c) +happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut33 #-} +happyIn34 :: (F c) -> (HappyAbsSyn ) +happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> (F c) +happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: (F c) -> (HappyAbsSyn ) +happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> (F c) +happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: (T c -> T c -> F c) -> (HappyAbsSyn ) +happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> (T c -> T c -> F c) +happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut36 #-} +happyIn37 :: (TermC -> TermC -> FormulaC) -> (HappyAbsSyn ) +happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn37 #-} +happyOut37 :: (HappyAbsSyn ) -> (TermC -> TermC -> FormulaC) +happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut37 #-} +happyIn38 :: (TermC -> TermC -> FormulaC) -> (HappyAbsSyn ) +happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn38 #-} +happyOut38 :: (HappyAbsSyn ) -> (TermC -> TermC -> FormulaC) +happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut38 #-} +happyIn39 :: (F c) -> (HappyAbsSyn ) +happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn39 #-} +happyOut39 :: (HappyAbsSyn ) -> (F c) +happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut39 #-} +happyIn40 :: (TermC) -> (HappyAbsSyn ) +happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (TermC) +happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: (TermC) -> (HappyAbsSyn ) +happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> (TermC) +happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: (TermC) -> (HappyAbsSyn ) +happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> (TermC) +happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: (AtomicWord) -> (HappyAbsSyn ) +happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> (AtomicWord) +happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: (AtomicWord) -> (HappyAbsSyn ) +happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> (AtomicWord) +happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: (TermC) -> (HappyAbsSyn ) +happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> (TermC) +happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: (TermC) -> (HappyAbsSyn ) +happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> (TermC) +happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut46 #-} +happyIn47 :: (T c) -> (HappyAbsSyn ) +happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn47 #-} +happyOut47 :: (HappyAbsSyn ) -> (T c) +happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut47 #-} +happyIn48 :: (TermC) -> (HappyAbsSyn ) +happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn48 #-} +happyOut48 :: (HappyAbsSyn ) -> (TermC) +happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut48 #-} +happyIn49 :: (String) -> (HappyAbsSyn ) +happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> (String) +happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: (String) -> (HappyAbsSyn ) +happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> (String) +happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: (TermC) -> (HappyAbsSyn ) +happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> (TermC) +happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (String) -> (HappyAbsSyn ) +happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (String) +happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: (String) -> (HappyAbsSyn ) +happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> (String) +happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: (V) -> (HappyAbsSyn ) +happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> (V) +happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: ([T c]) -> (HappyAbsSyn ) +happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> ([T c]) +happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: (GTerm) -> (HappyAbsSyn ) +happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> (GTerm) +happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: (UsefulInfo) -> (HappyAbsSyn ) +happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> (UsefulInfo) +happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: (UsefulInfo) -> (HappyAbsSyn ) +happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> (UsefulInfo) +happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: (TPTP_Input) -> (HappyAbsSyn ) +happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> (TPTP_Input) +happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ([AtomicWord]) -> (HappyAbsSyn ) +happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ([AtomicWord]) +happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: ([AtomicWord]) -> (HappyAbsSyn ) +happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> ([AtomicWord]) +happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: (GTerm) -> (HappyAbsSyn ) +happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> (GTerm) +happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: (GData) -> (HappyAbsSyn ) +happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> (GData) +happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: (GData) -> (HappyAbsSyn ) +happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> (GData) +happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: ([GTerm]) -> (HappyAbsSyn ) +happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> ([GTerm]) +happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: ([GTerm]) -> (HappyAbsSyn ) +happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> ([GTerm]) +happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: (AtomicWord) -> (HappyAbsSyn ) +happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> (AtomicWord) +happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: (AtomicWord) -> (HappyAbsSyn ) +happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> (AtomicWord) +happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: (String) -> (HappyAbsSyn ) +happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> (String) +happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: (String) -> (HappyAbsSyn ) +happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> (String) +happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: (Double) -> (HappyAbsSyn ) +happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> (Double) +happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: (String) -> (HappyAbsSyn ) +happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> (String) +happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: (String) -> (HappyAbsSyn ) +happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> (String) +happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (Token) -> (HappyAbsSyn ) +happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (Token) +happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: (Token) -> (HappyAbsSyn ) +happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> (Token) +happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: (Token) -> (HappyAbsSyn ) +happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> (Token) +happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: (Token) -> (HappyAbsSyn ) +happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> (Token) +happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: (Token) -> (HappyAbsSyn ) +happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> (Token) +happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: (Token) -> (HappyAbsSyn ) +happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> (Token) +happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: (Token) -> (HappyAbsSyn ) +happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> (Token) +happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: (Token) -> (HappyAbsSyn ) +happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> (Token) +happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (Token) -> (HappyAbsSyn ) +happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (Token) +happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: (AToken) -> (HappyAbsSyn ) +happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> (AToken) +happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: (Token) -> (HappyAbsSyn ) +happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> (Token) +happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: (Token) -> (HappyAbsSyn ) +happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> (Token) +happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: (Token) -> (HappyAbsSyn ) +happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> (Token) +happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: (Token) -> (HappyAbsSyn ) +happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> (Token) +happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: (Token) -> (HappyAbsSyn ) +happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> (Token) +happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: (Token) -> (HappyAbsSyn ) +happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> (Token) +happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: (Token) -> (HappyAbsSyn ) +happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> (Token) +happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: (Token) -> (HappyAbsSyn ) +happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> (Token) +happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: (Token) -> (HappyAbsSyn ) +happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> (Token) +happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: (Token) -> (HappyAbsSyn ) +happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> (Token) +happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: (Token) -> (HappyAbsSyn ) +happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> (Token) +happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: (Token) -> (HappyAbsSyn ) +happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> (Token) +happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: (Token) -> (HappyAbsSyn ) +happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> (Token) +happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: (Token) -> (HappyAbsSyn ) +happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> (Token) +happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: (Token) -> (HappyAbsSyn ) +happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> (Token) +happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (Token) -> (HappyAbsSyn ) +happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (Token) +happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: (String) -> (HappyAbsSyn ) +happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> (String) +happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (String) -> (HappyAbsSyn ) +happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (String) +happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: (String) -> (HappyAbsSyn ) +happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> (String) +happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: (String) -> (HappyAbsSyn ) +happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> (String) +happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (String) -> (HappyAbsSyn ) +happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (String) +happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (String) -> (HappyAbsSyn ) +happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (String) +happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: (Int) -> (HappyAbsSyn ) +happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> (Int) +happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: (Int) -> (HappyAbsSyn ) +happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> (Int) +happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (Double) -> (HappyAbsSyn ) +happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (Double) +happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: ([String]) -> (HappyAbsSyn ) +happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> ([String]) +happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyInTok :: (Token) -> (HappyAbsSyn ) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x7c\x00\x00\x00\x5b\x02\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x02\x79\x02\x79\x02\x50\x02\x50\x02\x50\x02\x00\x00\x00\x00\x50\x02\x00\x00\x00\x00\x52\x02\x41\x02\xd9\x00\xd9\x00\x00\x00\x65\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x02\x3f\x02\x3f\x02\x5f\x02\x00\x00\x5f\x02\x00\x00\x00\x00\x60\x02\x5e\x02\x3c\x02\x90\x01\x00\x00\x00\x00\x00\x00\x90\x01\x5a\x02\x00\x00\x5a\x02\x00\x00\xd9\x00\x39\x02\x58\x02\x38\x02\x00\x00\x00\x00\x38\x02\x00\x00\x57\x02\x43\x02\xfe\x01\xa6\x01\x43\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x00\x00\x00\x00\x00\x00\x44\x02\xa6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x00\x00\x30\x00\x00\x00\x45\x02\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x45\x02\x09\x00\x00\x00\x45\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x02\x18\x02\x18\x02\x18\x02\x18\x02\x18\x02\x18\x02\x18\x02\x18\x02\x36\x02\x00\x00\x29\x02\x00\x00\x00\x00\x48\x01\xe8\x01\xd9\x00\x00\x00\x16\x02\x00\x00\x00\x00\x00\x00\x00\x00\x28\x02\x25\x02\x00\x00\x48\x01\x13\x02\x24\x02\xb0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x02\xe8\x01\xe8\x01\xe8\x01\xe8\x01\x00\x00\xe8\x01\x00\x00\x00\x00\xff\x01\xff\x01\x00\x00\x03\x02\xa6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\xa6\x01\xf0\x01\xf0\x01\xf0\x01\xf0\x01\xf0\x01\xf0\x01\xf0\x01\xec\x01\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x01\xd8\x01\x00\x00\xe1\x01\xe7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x01\xe0\x01\xe0\x01\xe0\x01\x00\x00\x00\x00\xdc\x01\x00\x00\xd6\x01\x00\x00\x00\x00\xde\x01\x00\x00\x56\x02\x00\x00\xde\x01\xd7\x01\x00\x00\xb7\x01\x00\x00\x00\x00\x00\x00\xa6\x01\xc7\x01\xb8\x01\x00\x00\xb0\x02\xb0\x02\x97\x01\x00\x00\xb3\x01\x00\x00\x00\x00\x00\x00\xe8\x01\x92\x01\xa5\x01\x00\x00\xa6\x01\x00\x00\xa6\x01\x00\x00\x98\x01\xf5\x00\xa6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x01\x00\x00\xb0\x02\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x46\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x01\x4d\x01\x45\x01\x42\x01\x3d\x01\x3c\x01\x00\x00\x00\x00\x2b\x01\x00\x00\x00\x00\x0d\x00\x29\x01\xd3\x03\x7e\x03\x00\x00\x3e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x01\x1d\x01\x1c\x01\x39\x01\x00\x00\x60\x00\x00\x00\x00\x00\x2c\x01\x2a\x01\x06\x01\x4e\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x24\x01\x00\x00\x22\x01\x00\x00\x43\x06\x04\x01\x11\x01\xee\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x0a\x01\x08\x01\x8a\x03\xbe\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x00\x00\x00\x00\x00\x00\x09\x01\x34\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xff\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\x00\x00\x00\x00\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc5\x00\xc4\x00\xc3\x00\xc2\x00\xc0\x00\xac\x00\xa4\x00\xa3\x00\x0b\x00\x00\x00\xf3\xff\x00\x00\x00\x00\xdf\x03\x80\x04\x38\x06\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\xc1\x00\x00\x00\x32\x04\x9d\x00\xbb\x00\xff\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x24\x05\xfb\x04\xd2\x04\x76\x05\x00\x00\x4d\x05\x00\x00\x00\x00\x94\x00\x91\x00\x00\x00\xa5\x00\xda\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x26\x02\x8f\x00\x8e\x00\x8d\x00\x77\x00\x76\x00\x75\x00\x6b\x00\x8a\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x3d\x00\x00\x00\x83\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x6a\x00\x69\x00\x67\x00\x00\x00\x00\x00\x03\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x88\x05\x00\x00\x29\x00\x04\x00\x00\x00\xf1\xff\x00\x00\x00\x00\x00\x00\xfa\xff\xfb\xff\xf5\xff\x00\x00\xc8\x05\x0e\x06\xd0\xff\x00\x00\xbf\x00\x00\x00\x00\x00\x00\x00\xa9\x04\xa1\x00\xdf\xff\x00\x00\xcc\x01\x00\x00\x72\x01\x00\x00\x21\x00\x0e\x00\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xff\x00\x00\xb9\x05\xc4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfe\xff\x00\x00\x00\x00\xfe\xff\xfc\xff\xf9\xff\xf8\xff\xfb\xff\x00\x00\x00\x00\x00\x00\x5d\xff\x5d\xff\x5d\xff\xfa\xff\x67\xff\x5d\xff\x68\xff\x69\xff\x00\x00\x5d\xff\x00\x00\x00\x00\xfd\xff\x00\x00\x8e\xff\x8c\xff\x83\xff\x82\xff\x81\xff\x8b\xff\x84\xff\x8d\xff\x5d\xff\x5d\xff\x5d\xff\x00\x00\x80\xff\x9f\xff\x85\xff\x5c\xff\x00\x00\x00\x00\x5d\xff\x00\x00\x5f\xff\x61\xff\x66\xff\x00\x00\x00\x00\xf3\xff\x00\x00\x7c\xff\x00\x00\x5d\xff\x00\x00\x5d\xff\x7f\xff\xa1\xff\x5d\xff\x7e\xff\x00\x00\x9e\xff\x00\x00\x00\x00\xf4\xff\xf2\xff\xf0\xff\xef\xff\xed\xff\xec\xff\xf1\xff\xe5\xff\xe4\xff\xdd\xff\x00\x00\x00\x00\xe3\xff\xca\xff\xc9\xff\xc6\xff\xc5\xff\xc8\xff\x00\x00\xbe\xff\xc7\xff\xb9\xff\xb7\xff\xbb\xff\xb5\xff\xb4\xff\xc4\xff\xb0\xff\xae\xff\xbf\xff\xac\xff\xaa\xff\xbd\xff\xb6\xff\xad\xff\xa9\xff\xb3\xff\x00\x00\xd3\xff\xd2\xff\xcb\xff\xb2\xff\x8a\xff\x89\xff\xa8\xff\x87\xff\x86\xff\x88\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\xf4\xff\xdb\xff\xd9\xff\xd5\xff\xd7\xff\x00\x00\x00\x00\x00\x00\xa0\xff\x5d\xff\x7b\xff\x7d\xff\x9d\xff\xd6\xff\x00\x00\x00\x00\xda\xff\x00\x00\x5d\xff\x00\x00\x00\x00\x5e\xff\x60\xff\x62\xff\x63\xff\x64\xff\x65\xff\x6a\xff\x6d\xff\x6e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\xff\x00\x00\xc1\xff\xc0\xff\x5d\xff\x5d\xff\xde\xff\x00\x00\x00\x00\xd1\xff\xd0\xff\xce\xff\xcd\xff\xcc\xff\xcf\xff\x00\x00\x00\x00\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x5d\xff\x00\x00\x00\x00\x6c\xff\x71\xff\x72\xff\x73\xff\x74\xff\x75\xff\x76\xff\xea\xff\xe7\xff\xee\xff\x00\x00\xe0\xff\x6f\xff\x70\xff\xd4\xff\xbc\xff\xb1\xff\xba\xff\xc3\xff\xa7\xff\x00\x00\x00\x00\x00\x00\xe2\xff\x97\xff\xa3\xff\xa5\xff\x9c\xff\x94\xff\x9a\xff\x99\xff\x96\xff\x00\x00\x95\xff\x00\x00\x00\x00\x6b\xff\xd9\xff\xdc\xff\xd8\xff\xf6\xff\x00\x00\x90\xff\x00\x00\x92\xff\x00\x00\x00\x00\x5d\xff\xf5\xff\x00\x00\xab\xff\xaf\xff\xb8\xff\x00\x00\x00\x00\x00\x00\xe8\xff\x00\x00\xeb\xff\x00\x00\xf7\xff\xea\xff\xe7\xff\x00\x00\xdf\xff\xa6\xff\xa4\xff\xa2\xff\x77\xff\x9b\xff\x00\x00\x91\xff\x00\x00\x00\x00\x93\xff\x8f\xff\x98\xff\xe1\xff\xe6\xff\xe9\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x15\x00\x0d\x00\x15\x00\x0f\x00\x10\x00\x47\x00\x12\x00\x20\x00\x21\x00\x22\x00\x05\x00\x17\x00\x18\x00\x47\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x11\x00\x12\x00\x0e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x0c\x00\x4f\x00\x0c\x00\x05\x00\x11\x00\x12\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x35\x00\x69\x00\x40\x00\x41\x00\x42\x00\x43\x00\x49\x00\x45\x00\x46\x00\x11\x00\x12\x00\x56\x00\x57\x00\x4a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x0e\x00\x5b\x00\x4a\x00\x5b\x00\x4b\x00\x06\x00\x44\x00\x58\x00\x59\x00\x06\x00\x4a\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x5a\x00\x0d\x00\x37\x00\x0f\x00\x10\x00\x60\x00\x12\x00\x46\x00\x20\x00\x21\x00\x46\x00\x17\x00\x18\x00\x4a\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x5b\x00\x37\x00\x5b\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x45\x00\x5d\x00\x5e\x00\x5f\x00\x45\x00\x18\x00\x19\x00\x1a\x00\x5a\x00\x38\x00\x11\x00\x12\x00\x4f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x24\x00\x45\x00\x46\x00\x5d\x00\x5e\x00\x5f\x00\x56\x00\x5d\x00\x5e\x00\x5f\x00\x4a\x00\x5d\x00\x5e\x00\x5f\x00\x47\x00\x65\x00\x47\x00\x47\x00\x11\x00\x65\x00\x58\x00\x59\x00\x11\x00\x4a\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x4a\x00\x0d\x00\x49\x00\x0f\x00\x10\x00\x4b\x00\x12\x00\x47\x00\x47\x00\x32\x00\x69\x00\x17\x00\x18\x00\x32\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x69\x00\x69\x00\x69\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x36\x00\x69\x00\x69\x00\x69\x00\x20\x00\x69\x00\x22\x00\x3d\x00\x69\x00\x40\x00\x41\x00\x42\x00\x43\x00\x47\x00\x45\x00\x46\x00\x64\x00\x69\x00\x48\x00\x47\x00\x64\x00\x15\x00\x69\x00\x69\x00\x69\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x19\x00\x69\x00\x58\x00\x59\x00\x15\x00\x16\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\x69\x00\x12\x00\x69\x00\x69\x00\x69\x00\x69\x00\x17\x00\x18\x00\x69\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x46\x00\x46\x00\x46\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x48\x00\x4a\x00\x49\x00\x69\x00\x5a\x00\x5b\x00\x69\x00\x40\x00\x41\x00\x42\x00\x43\x00\x4b\x00\x45\x00\x46\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x4a\x00\x69\x00\x4a\x00\x69\x00\x58\x00\x59\x00\x48\x00\x47\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\x4a\x00\x12\x00\x69\x00\x69\x00\x69\x00\x4a\x00\x17\x00\x18\x00\x46\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x69\x00\x46\x00\x69\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x69\x00\x69\x00\x01\x00\x18\x00\x19\x00\x1a\x00\x69\x00\x46\x00\x02\x00\x16\x00\x0a\x00\x20\x00\x1f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x03\x00\x45\x00\x46\x00\x13\x00\x14\x00\x24\x00\x04\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x58\x00\x59\x00\x05\x00\x16\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\x06\x00\x12\x00\x01\x00\x0a\x00\x05\x00\x02\x00\x17\x00\x18\x00\x04\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x05\x00\x15\x00\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x01\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x40\x00\x41\x00\x42\x00\x43\x00\x16\x00\x45\x00\x46\x00\x06\x00\x24\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x1f\x00\x24\x00\x58\x00\x59\x00\x02\x00\x02\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\x24\x00\x12\x00\x11\x00\x24\x00\x05\x00\x24\x00\x17\x00\x18\x00\x16\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x03\x00\x05\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x03\x00\x04\x00\x04\x00\x24\x00\x24\x00\x06\x00\x05\x00\x24\x00\x03\x00\x02\x00\x24\x00\x05\x00\x24\x00\x40\x00\x41\x00\x42\x00\x43\x00\x05\x00\x45\x00\x46\x00\x1b\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x24\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x01\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x25\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x03\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\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\x46\x00\xff\xff\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\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\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\x46\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\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x0f\x00\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\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\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\x46\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\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x13\x00\x14\x00\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x14\x00\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\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\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\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\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\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\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x40\x00\x41\x00\x42\x00\x43\x00\x32\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x32\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\x32\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\x48\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\xff\xff\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\xff\xff\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x32\x00\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\x40\x00\x32\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\x48\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\xff\xff\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x39\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x39\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\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\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x00\x01\x42\x00\x43\x00\x44\x00\x45\x00\xde\x00\x46\x00\x8a\x00\x47\x00\x48\x00\x01\x01\x49\x00\x9c\x00\x9d\x00\x9e\x00\x8d\x00\x4a\x00\x4b\x00\x03\x01\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xba\xff\xba\xff\x05\x01\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x06\x01\xf6\x00\xf1\x00\xb5\x00\xb1\xff\xb1\xff\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xe7\x00\xfb\x00\x62\x00\x63\x00\x64\x00\x65\x00\xfe\x00\x1a\x00\x66\x00\xbc\xff\xbc\xff\x9f\x00\xa0\x00\xff\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xef\x00\x8b\x00\xe8\x00\x8b\x00\xdf\x00\x31\x00\x26\x00\x67\x00\x68\x00\x33\x00\x8e\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x98\x00\x42\x00\x43\x00\x44\x00\x45\x00\xf0\x00\x46\x00\x07\x00\x47\x00\x48\x00\x27\x00\x49\x00\xe0\x00\x9c\x00\x9d\x00\xe4\x00\x4a\x00\x4b\x00\x8e\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xf2\x00\x07\x00\xf2\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x32\x00\x08\x00\x09\x00\x0a\x00\x32\x00\x0c\x00\x0d\x00\x0e\x00\xf0\x00\x29\x00\xa2\x00\xa3\x00\xe5\x00\x62\x00\x63\x00\x64\x00\x65\x00\x0f\x00\x1a\x00\x66\x00\x08\x00\x09\x00\x0a\x00\x9f\x00\x1b\x00\x1c\x00\x1d\x00\x2a\x00\x1b\x00\x1c\x00\x1d\x00\xe9\x00\x1f\x00\xea\x00\xeb\x00\xf7\x00\x1f\x00\x67\x00\x68\x00\xc1\x00\xec\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\xed\x00\x46\x00\xee\x00\x47\x00\x48\x00\xf3\x00\x49\x00\xb6\x00\xce\x00\xc2\x00\xb7\x00\x4a\x00\x4b\x00\xc2\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xb8\x00\xb9\x00\xba\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\xf9\x00\xbb\x00\xbc\x00\xbd\x00\x23\x00\xc3\x00\x24\x00\xfa\x00\xc4\x00\x62\x00\x63\x00\x64\x00\x65\x00\xda\x00\x1a\x00\x66\x00\x6d\x00\xdb\x00\xd7\x00\xdd\x00\x6d\x00\xb5\x00\x85\x00\x8f\x00\x90\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xa5\x00\x91\x00\x67\x00\x68\x00\xb5\x00\x8d\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x04\x01\x48\x00\x92\x00\x49\x00\x93\x00\x94\x00\x95\x00\x96\x00\x4a\x00\x4b\x00\x97\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x99\x00\x9a\x00\x9b\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xa4\x00\x81\x00\x82\x00\x84\x00\xac\x00\xad\x00\x39\x00\x62\x00\x63\x00\x64\x00\x65\x00\x3a\x00\x1a\x00\x66\x00\x74\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x77\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x3f\x00\x3c\x00\x40\x00\x34\x00\x67\x00\x68\x00\x35\x00\x37\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xf4\x00\x48\x00\x2c\x00\x49\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x4a\x00\x4b\x00\x13\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x25\x00\x15\x00\x28\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x0f\x00\x11\x00\x15\x00\x0c\x00\x0d\x00\x0e\x00\x12\x00\x16\x00\x39\x00\x8d\x00\xe7\x00\x23\x00\x78\x00\x62\x00\x63\x00\x64\x00\x65\x00\x37\x00\x1a\x00\x66\x00\x72\x00\x73\x00\x11\x00\x84\x00\x74\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x77\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x67\x00\x68\x00\x2c\x00\x8d\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xf5\x00\x48\x00\x3c\x00\x49\x00\x15\x00\xe7\x00\x2c\x00\x39\x00\x4a\x00\x4b\x00\x84\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x2c\x00\xb5\x00\x39\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x15\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x77\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x62\x00\x63\x00\x64\x00\x65\x00\x8d\x00\x1a\x00\x66\x00\x3c\x00\x11\x00\x74\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x77\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x78\x00\x11\x00\x67\x00\x68\x00\x39\x00\x39\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xbe\x00\x48\x00\x11\x00\x49\x00\xa2\x00\x11\x00\x2c\x00\x11\x00\x4a\x00\x4b\x00\x8d\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x15\x00\x37\x00\x2c\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x37\x00\x84\x00\x84\x00\x11\x00\x11\x00\x3c\x00\x2c\x00\x11\x00\x37\x00\x39\x00\x11\x00\x2c\x00\x11\x00\x62\x00\x63\x00\x64\x00\x65\x00\x2c\x00\x1a\x00\x66\x00\x22\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x11\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x15\x00\x00\x00\x00\x00\x00\x00\x67\x00\x68\x00\xff\xff\x00\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xbf\x00\x48\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x37\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\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x66\x00\x00\x00\x0c\x00\x0d\x00\x0e\x00\x22\x00\x75\x00\x76\x00\x00\x00\x78\x00\x23\x00\x79\x00\x24\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xc0\x00\x48\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\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\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x66\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\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xa3\x00\x48\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\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\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x66\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\x67\x00\x68\x00\x00\x00\x00\x00\x69\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x80\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x89\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x24\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x80\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xdc\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\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\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\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\x80\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x87\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x88\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\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\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\xf8\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\xcb\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\xcc\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\xcd\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x54\x00\xc6\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xc7\x00\x5c\x00\x5d\x00\xc8\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x62\x00\x63\x00\x64\x00\x65\x00\xcf\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xd2\x00\xd3\x00\xd4\x00\xe2\x00\x00\x00\xd5\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x1a\x00\x00\x00\x00\x00\xd7\x00\xe3\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\xd8\x00\xd9\x00\xcf\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\xe1\x00\xd2\x00\xd3\x00\xd4\x00\x02\x01\x00\x00\xd5\x00\xcf\x00\x00\x00\xd6\x00\x00\x00\x1a\x00\x00\x00\x00\x00\xd7\x00\xe1\x00\xd2\x00\xd3\x00\xd4\x00\xfd\x00\x00\x00\xd5\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x1a\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\xd8\x00\xd9\x00\x00\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\xd8\x00\xd9\x00\x00\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\xcf\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\x00\x00\x00\x00\xd5\x00\xcf\x00\x00\x00\xd6\x00\x00\x00\x1a\x00\x00\x00\x00\x00\xd7\x00\xfc\x00\xd2\x00\xd3\x00\xd4\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x1a\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\xd8\x00\xd9\x00\x00\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\xd8\x00\xd9\x00\x86\x00\x6d\x00\x1f\x00\x6e\x00\x6f\x00\x70\x00\x3e\x00\x19\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\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\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = Happy_Data_Array.array (1, 163) [ + (1 , happyReduce_1), + (2 , happyReduce_2), + (3 , happyReduce_3), + (4 , happyReduce_4), + (5 , happyReduce_5), + (6 , happyReduce_6), + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (13 , happyReduce_13), + (14 , happyReduce_14), + (15 , happyReduce_15), + (16 , happyReduce_16), + (17 , happyReduce_17), + (18 , happyReduce_18), + (19 , happyReduce_19), + (20 , happyReduce_20), + (21 , happyReduce_21), + (22 , happyReduce_22), + (23 , happyReduce_23), + (24 , happyReduce_24), + (25 , happyReduce_25), + (26 , happyReduce_26), + (27 , happyReduce_27), + (28 , happyReduce_28), + (29 , happyReduce_29), + (30 , happyReduce_30), + (31 , happyReduce_31), + (32 , happyReduce_32), + (33 , happyReduce_33), + (34 , happyReduce_34), + (35 , happyReduce_35), + (36 , happyReduce_36), + (37 , happyReduce_37), + (38 , happyReduce_38), + (39 , happyReduce_39), + (40 , happyReduce_40), + (41 , happyReduce_41), + (42 , happyReduce_42), + (43 , happyReduce_43), + (44 , happyReduce_44), + (45 , happyReduce_45), + (46 , happyReduce_46), + (47 , happyReduce_47), + (48 , happyReduce_48), + (49 , happyReduce_49), + (50 , happyReduce_50), + (51 , happyReduce_51), + (52 , happyReduce_52), + (53 , happyReduce_53), + (54 , happyReduce_54), + (55 , happyReduce_55), + (56 , happyReduce_56), + (57 , happyReduce_57), + (58 , happyReduce_58), + (59 , happyReduce_59), + (60 , happyReduce_60), + (61 , happyReduce_61), + (62 , happyReduce_62), + (63 , happyReduce_63), + (64 , happyReduce_64), + (65 , happyReduce_65), + (66 , happyReduce_66), + (67 , happyReduce_67), + (68 , happyReduce_68), + (69 , happyReduce_69), + (70 , happyReduce_70), + (71 , happyReduce_71), + (72 , happyReduce_72), + (73 , happyReduce_73), + (74 , happyReduce_74), + (75 , happyReduce_75), + (76 , happyReduce_76), + (77 , happyReduce_77), + (78 , happyReduce_78), + (79 , happyReduce_79), + (80 , happyReduce_80), + (81 , happyReduce_81), + (82 , happyReduce_82), + (83 , happyReduce_83), + (84 , happyReduce_84), + (85 , happyReduce_85), + (86 , happyReduce_86), + (87 , happyReduce_87), + (88 , happyReduce_88), + (89 , happyReduce_89), + (90 , happyReduce_90), + (91 , happyReduce_91), + (92 , happyReduce_92), + (93 , happyReduce_93), + (94 , happyReduce_94), + (95 , happyReduce_95), + (96 , happyReduce_96), + (97 , happyReduce_97), + (98 , happyReduce_98), + (99 , happyReduce_99), + (100 , happyReduce_100), + (101 , happyReduce_101), + (102 , happyReduce_102), + (103 , happyReduce_103), + (104 , happyReduce_104), + (105 , happyReduce_105), + (106 , happyReduce_106), + (107 , happyReduce_107), + (108 , happyReduce_108), + (109 , happyReduce_109), + (110 , happyReduce_110), + (111 , happyReduce_111), + (112 , happyReduce_112), + (113 , happyReduce_113), + (114 , happyReduce_114), + (115 , happyReduce_115), + (116 , happyReduce_116), + (117 , happyReduce_117), + (118 , happyReduce_118), + (119 , happyReduce_119), + (120 , happyReduce_120), + (121 , happyReduce_121), + (122 , happyReduce_122), + (123 , happyReduce_123), + (124 , happyReduce_124), + (125 , happyReduce_125), + (126 , happyReduce_126), + (127 , happyReduce_127), + (128 , happyReduce_128), + (129 , happyReduce_129), + (130 , happyReduce_130), + (131 , happyReduce_131), + (132 , happyReduce_132), + (133 , happyReduce_133), + (134 , happyReduce_134), + (135 , happyReduce_135), + (136 , happyReduce_136), + (137 , happyReduce_137), + (138 , happyReduce_138), + (139 , happyReduce_139), + (140 , happyReduce_140), + (141 , happyReduce_141), + (142 , happyReduce_142), + (143 , happyReduce_143), + (144 , happyReduce_144), + (145 , happyReduce_145), + (146 , happyReduce_146), + (147 , happyReduce_147), + (148 , happyReduce_148), + (149 , happyReduce_149), + (150 , happyReduce_150), + (151 , happyReduce_151), + (152 , happyReduce_152), + (153 , happyReduce_153), + (154 , happyReduce_154), + (155 , happyReduce_155), + (156 , happyReduce_156), + (157 , happyReduce_157), + (158 , happyReduce_158), + (159 , happyReduce_159), + (160 , happyReduce_160), + (161 , happyReduce_161), + (162 , happyReduce_162), + (163 , happyReduce_163) + ] + +happy_n_terms = 38 :: Int +happy_n_nonterms = 106 :: Int + +happyReduce_1 = happySpecReduce_0 0# happyReduction_1 +happyReduction_1 = happyIn4 + ([] + ) + +happyReduce_2 = happySpecReduce_2 0# happyReduction_2 +happyReduction_2 happy_x_2 + happy_x_1 + = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut4 happy_x_2 of { happy_var_2 -> + happyIn4 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_3 = happySpecReduce_1 1# happyReduction_3 +happyReduction_3 happy_x_1 + = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn5 + (happy_var_1 + )} + +happyReduce_4 = happySpecReduce_1 1# happyReduction_4 +happyReduction_4 happy_x_1 + = case happyOut59 happy_x_1 of { happy_var_1 -> + happyIn5 + (happy_var_1 + )} + +happyReduce_5 = happySpecReduce_1 1# happyReduction_5 +happyReduction_5 happy_x_1 + = case happyOutTok happy_x_1 of { (CommentToken happy_var_1) -> + happyIn5 + (Comment happy_var_1 + )} + +happyReduce_6 = happySpecReduce_1 2# happyReduction_6 +happyReduction_6 happy_x_1 + = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn6 + (happy_var_1 + )} + +happyReduce_7 = happySpecReduce_1 2# happyReduction_7 +happyReduction_7 happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn6 + (happy_var_1 + )} + +happyReduce_8 = happyReduce 10# 3# happyReduction_8 +happyReduction_8 (happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + 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 happyOut67 happy_x_3 of { happy_var_3 -> + case happyOut10 happy_x_5 of { happy_var_5 -> + case happyOut11 happy_x_7 of { happy_var_7 -> + case happyOut9 happy_x_8 of { happy_var_8 -> + happyIn7 + (AFormula happy_var_3 happy_var_5 happy_var_7 happy_var_8 + ) `HappyStk` happyRest}}}} + +happyReduce_9 = happyReduce 10# 4# happyReduction_9 +happyReduction_9 (happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + 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 happyOut67 happy_x_3 of { happy_var_3 -> + case happyOut10 happy_x_5 of { happy_var_5 -> + case happyOut23 happy_x_7 of { happy_var_7 -> + case happyOut9 happy_x_8 of { happy_var_8 -> + happyIn8 + (AFormula happy_var_3 happy_var_5 (univquant_free_vars happy_var_7) happy_var_8 + ) `HappyStk` happyRest}}}} + +happyReduce_10 = happySpecReduce_3 5# happyReduction_10 +happyReduction_10 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_2 of { happy_var_2 -> + case happyOut57 happy_x_3 of { happy_var_3 -> + happyIn9 + (Annotations happy_var_2 happy_var_3 + )}} + +happyReduce_11 = happySpecReduce_0 5# happyReduction_11 +happyReduction_11 = happyIn9 + (NoAnnotations + ) + +happyReduce_12 = happySpecReduce_1 6# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn10 + (Role happy_var_1 + )} + +happyReduce_13 = happySpecReduce_1 7# happyReduction_13 +happyReduction_13 happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + happyIn11 + (happy_var_1 + )} + +happyReduce_14 = happySpecReduce_1 7# happyReduction_14 +happyReduction_14 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn11 + (happy_var_1 + )} + +happyReduce_15 = happySpecReduce_1 8# happyReduction_15 +happyReduction_15 happy_x_1 + = case happyOut13 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_16 = happySpecReduce_1 8# happyReduction_16 +happyReduction_16 happy_x_1 + = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_17 = happySpecReduce_3 9# happyReduction_17 +happyReduction_17 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut29 happy_x_2 of { happy_var_2 -> + case happyOut19 happy_x_3 of { happy_var_3 -> + happyIn13 + (happy_var_2 happy_var_1 happy_var_3 + )}}} + +happyReduce_18 = happySpecReduce_1 10# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +happyReduce_19 = happySpecReduce_1 10# happyReduction_19 +happyReduction_19 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn14 + (happy_var_1 + )} + +happyReduce_20 = happyReduce 4# 11# happyReduction_20 +happyReduction_20 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_3 of { happy_var_3 -> + case happyOut16 happy_x_4 of { happy_var_4 -> + happyIn15 + (foldl (.|.) (happy_var_1 .|. happy_var_3) happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_21 = happySpecReduce_0 12# happyReduction_21 +happyReduction_21 = happyIn16 + ([] + ) + +happyReduce_22 = happySpecReduce_3 12# happyReduction_22 +happyReduction_22 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { happy_var_2 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + happyIn16 + (happy_var_2 : happy_var_3 + )}} + +happyReduce_23 = happyReduce 4# 13# happyReduction_23 +happyReduction_23 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_3 of { happy_var_3 -> + case happyOut18 happy_x_4 of { happy_var_4 -> + happyIn17 + (foldl (.&.) (happy_var_1 .&. happy_var_3) happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_24 = happySpecReduce_0 14# happyReduction_24 +happyReduction_24 = happyIn18 + ([] + ) + +happyReduce_25 = happySpecReduce_3 14# happyReduction_25 +happyReduction_25 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { happy_var_2 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + happyIn18 + (happy_var_2 : happy_var_3 + )}} + +happyReduce_26 = happySpecReduce_1 15# happyReduction_26 +happyReduction_26 happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + happyIn19 + (happy_var_1 + )} + +happyReduce_27 = happySpecReduce_1 15# happyReduction_27 +happyReduction_27 happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn19 + (happy_var_1 + )} + +happyReduce_28 = happySpecReduce_1 15# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut31 happy_x_1 of { happy_var_1 -> + happyIn19 + (happy_var_1 + )} + +happyReduce_29 = happySpecReduce_3 15# happyReduction_29 +happyReduction_29 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut11 happy_x_2 of { happy_var_2 -> + happyIn19 + (happy_var_2 + )} + +happyReduce_30 = happyReduce 6# 16# happyReduction_30 +happyReduction_30 (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 happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + case happyOut19 happy_x_6 of { happy_var_6 -> + happyIn20 + (happy_var_1 happy_var_3 happy_var_6 `withComments` comm happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_31 = happySpecReduce_1 17# happyReduction_31 +happyReduction_31 happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn21 + ([happy_var_1] + )} + +happyReduce_32 = happySpecReduce_3 17# happyReduction_32 +happyReduction_32 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + happyIn21 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_33 = happySpecReduce_2 18# happyReduction_33 +happyReduction_33 happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_2 of { happy_var_2 -> + happyIn22 + (happy_var_1 happy_var_2 + )}} + +happyReduce_34 = happySpecReduce_1 18# happyReduction_34 +happyReduction_34 happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn22 + (happy_var_1 + )} + +happyReduce_35 = happySpecReduce_3 19# happyReduction_35 +happyReduction_35 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn23 + (happy_var_2 + )} + +happyReduce_36 = happySpecReduce_1 19# happyReduction_36 +happyReduction_36 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn23 + (happy_var_1 + )} + +happyReduce_37 = happySpecReduce_2 20# happyReduction_37 +happyReduction_37 happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_2 of { happy_var_2 -> + happyIn24 + (foldl (.|.) happy_var_1 happy_var_2 + )}} + +happyReduce_38 = happySpecReduce_0 21# happyReduction_38 +happyReduction_38 = happyIn25 + ([] + ) + +happyReduce_39 = happySpecReduce_3 21# happyReduction_39 +happyReduction_39 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn25 + (happy_var_2 : happy_var_3 + )}} + +happyReduce_40 = happySpecReduce_1 22# happyReduction_40 +happyReduction_40 happy_x_1 + = case happyOut31 happy_x_1 of { happy_var_1 -> + happyIn26 + (happy_var_1 + )} + +happyReduce_41 = happySpecReduce_2 22# happyReduction_41 +happyReduction_41 happy_x_2 + happy_x_1 + = case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn26 + ((.~.) happy_var_2 + )} + +happyReduce_42 = happySpecReduce_1 22# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn26 + (happy_var_1 + )} + +happyReduce_43 = happySpecReduce_3 23# happyReduction_43 +happyReduction_43 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_2 of { happy_var_2 -> + case happyOut40 happy_x_3 of { happy_var_3 -> + happyIn27 + (happy_var_2 happy_var_1 happy_var_3 + )}}} + +happyReduce_44 = happySpecReduce_1 24# happyReduction_44 +happyReduction_44 happy_x_1 + = happyIn28 + (for_all + ) + +happyReduce_45 = happySpecReduce_1 24# happyReduction_45 +happyReduction_45 happy_x_1 + = happyIn28 + (exists + ) + +happyReduce_46 = happySpecReduce_1 25# happyReduction_46 +happyReduction_46 happy_x_1 + = happyIn29 + ((.<=>.) + ) + +happyReduce_47 = happySpecReduce_1 25# happyReduction_47 +happyReduction_47 happy_x_1 + = happyIn29 + ((.=>.) + ) + +happyReduce_48 = happySpecReduce_1 25# happyReduction_48 +happyReduction_48 happy_x_1 + = happyIn29 + ((.<=.) + ) + +happyReduce_49 = happySpecReduce_1 25# happyReduction_49 +happyReduction_49 happy_x_1 + = happyIn29 + ((.<~>.) + ) + +happyReduce_50 = happySpecReduce_1 25# happyReduction_50 +happyReduction_50 happy_x_1 + = happyIn29 + ((.~|.) + ) + +happyReduce_51 = happySpecReduce_1 25# happyReduction_51 +happyReduction_51 happy_x_1 + = happyIn29 + ((.~&.) + ) + +happyReduce_52 = happySpecReduce_1 26# happyReduction_52 +happyReduction_52 happy_x_1 + = happyIn30 + ((.~.) + ) + +happyReduce_53 = happySpecReduce_1 27# happyReduction_53 +happyReduction_53 happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn31 + (happy_var_1 + )} + +happyReduce_54 = happySpecReduce_1 27# happyReduction_54 +happyReduction_54 happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn31 + (happy_var_1 + )} + +happyReduce_55 = happySpecReduce_1 27# happyReduction_55 +happyReduction_55 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn31 + (happy_var_1 + )} + +happyReduce_56 = happySpecReduce_1 28# happyReduction_56 +happyReduction_56 happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + happyIn32 + (fApp2pApp happy_var_1 + )} + +happyReduce_57 = happySpecReduce_1 29# happyReduction_57 +happyReduction_57 happy_x_1 + = case happyOut34 happy_x_1 of { happy_var_1 -> + happyIn33 + (happy_var_1 + )} + +happyReduce_58 = happySpecReduce_1 29# happyReduction_58 +happyReduction_58 happy_x_1 + = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn33 + (happy_var_1 + )} + +happyReduce_59 = happySpecReduce_1 30# happyReduction_59 +happyReduction_59 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn34 + (fApp2pApp happy_var_1 + )} + +happyReduce_60 = happySpecReduce_3 31# happyReduction_60 +happyReduction_60 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_2 of { happy_var_2 -> + case happyOut40 happy_x_3 of { happy_var_3 -> + happyIn35 + (happy_var_2 happy_var_1 happy_var_3 + )}}} + +happyReduce_61 = happySpecReduce_1 32# happyReduction_61 +happyReduction_61 happy_x_1 + = case happyOut37 happy_x_1 of { happy_var_1 -> + happyIn36 + (happy_var_1 + )} + +happyReduce_62 = happySpecReduce_1 33# happyReduction_62 +happyReduction_62 happy_x_1 + = happyIn37 + ((.=.) + ) + +happyReduce_63 = happySpecReduce_1 34# happyReduction_63 +happyReduction_63 happy_x_1 + = happyIn38 + ((.!=.) + ) + +happyReduce_64 = happySpecReduce_1 35# happyReduction_64 +happyReduction_64 happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn39 + (fApp2pApp happy_var_1 + )} + +happyReduce_65 = happySpecReduce_1 36# happyReduction_65 +happyReduction_65 happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn40 + (happy_var_1 + )} + +happyReduce_66 = happySpecReduce_1 36# happyReduction_66 +happyReduction_66 happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn40 + (var happy_var_1 + )} + +happyReduce_67 = happySpecReduce_1 37# happyReduction_67 +happyReduction_67 happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + happyIn41 + (happy_var_1 + )} + +happyReduce_68 = happySpecReduce_1 37# happyReduction_68 +happyReduction_68 happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + happyIn41 + (happy_var_1 + )} + +happyReduce_69 = happySpecReduce_1 37# happyReduction_69 +happyReduction_69 happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn41 + (happy_var_1 + )} + +happyReduce_70 = happySpecReduce_1 38# happyReduction_70 +happyReduction_70 happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> + happyIn42 + (fApp happy_var_1 [] + )} + +happyReduce_71 = happyReduce 4# 38# happyReduction_71 +happyReduction_71 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn42 + (fApp happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_72 = happySpecReduce_1 39# happyReduction_72 +happyReduction_72 happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + happyIn43 + (happy_var_1 + )} + +happyReduce_73 = happySpecReduce_1 40# happyReduction_73 +happyReduction_73 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn44 + (happy_var_1 + )} + +happyReduce_74 = happySpecReduce_1 41# happyReduction_74 +happyReduction_74 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn45 + (happy_var_1 + )} + +happyReduce_75 = happySpecReduce_1 41# happyReduction_75 +happyReduction_75 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn45 + (happy_var_1 + )} + +happyReduce_76 = happySpecReduce_1 42# happyReduction_76 +happyReduction_76 happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn46 + (numberLitTerm happy_var_1 + )} + +happyReduce_77 = happySpecReduce_1 42# happyReduction_77 +happyReduction_77 happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn46 + (distinctObjectTerm (stripQuotes '"' happy_var_1) + )} + +happyReduce_78 = happySpecReduce_1 43# happyReduction_78 +happyReduction_78 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn47 + (happy_var_1 + )} + +happyReduce_79 = happySpecReduce_1 44# happyReduction_79 +happyReduction_79 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn48 + (fApp (AtomicWord happy_var_1) [] + )} + +happyReduce_80 = happyReduce 4# 44# happyReduction_80 +happyReduction_80 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut50 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn48 + (fApp (AtomicWord happy_var_1) happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_81 = happySpecReduce_1 45# happyReduction_81 +happyReduction_81 happy_x_1 + = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn49 + (happy_var_1 + )} + +happyReduce_82 = happySpecReduce_1 46# happyReduction_82 +happyReduction_82 happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_83 = happySpecReduce_1 47# happyReduction_83 +happyReduction_83 happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + happyIn51 + (fApp (AtomicWord happy_var_1) [] + )} + +happyReduce_84 = happyReduce 4# 47# happyReduction_84 +happyReduction_84 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut53 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn51 + (fApp (AtomicWord happy_var_1) happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_85 = happySpecReduce_1 48# happyReduction_85 +happyReduction_85 happy_x_1 + = case happyOut53 happy_x_1 of { happy_var_1 -> + happyIn52 + (happy_var_1 + )} + +happyReduce_86 = happySpecReduce_1 49# happyReduction_86 +happyReduction_86 happy_x_1 + = case happyOut70 happy_x_1 of { happy_var_1 -> + happyIn53 + (happy_var_1 + )} + +happyReduce_87 = happySpecReduce_1 50# happyReduction_87 +happyReduction_87 happy_x_1 + = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn54 + (V happy_var_1 + )} + +happyReduce_88 = happySpecReduce_1 51# happyReduction_88 +happyReduction_88 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn55 + ([happy_var_1] + )} + +happyReduce_89 = happySpecReduce_3 51# happyReduction_89 +happyReduction_89 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn55 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_90 = happySpecReduce_1 52# happyReduction_90 +happyReduction_90 happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn56 + (happy_var_1 + )} + +happyReduce_91 = happySpecReduce_2 53# happyReduction_91 +happyReduction_91 happy_x_2 + happy_x_1 + = case happyOut58 happy_x_2 of { happy_var_2 -> + happyIn57 + (happy_var_2 + )} + +happyReduce_92 = happySpecReduce_0 53# happyReduction_92 +happyReduction_92 = happyIn57 + (NoUsefulInfo + ) + +happyReduce_93 = happySpecReduce_1 54# happyReduction_93 +happyReduction_93 happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn58 + (UsefulInfo happy_var_1 + )} + +happyReduce_94 = happyReduce 6# 55# happyReduction_94 +happyReduction_94 (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 happyOut72 happy_x_3 of { happy_var_3 -> + case happyOut60 happy_x_4 of { happy_var_4 -> + happyIn59 + (Include happy_var_3 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_95 = happyReduce 4# 56# happyReduction_95 +happyReduction_95 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut61 happy_x_3 of { happy_var_3 -> + happyIn60 + (happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_96 = happySpecReduce_0 56# happyReduction_96 +happyReduction_96 = happyIn60 + ([] + ) + +happyReduce_97 = happySpecReduce_1 57# happyReduction_97 +happyReduction_97 happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn61 + ([happy_var_1] + )} + +happyReduce_98 = happySpecReduce_3 57# happyReduction_98 +happyReduction_98 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_3 of { happy_var_3 -> + happyIn61 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_99 = happySpecReduce_1 58# happyReduction_99 +happyReduction_99 happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn62 + (GTerm happy_var_1 + )} + +happyReduce_100 = happySpecReduce_3 58# happyReduction_100 +happyReduction_100 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_3 of { happy_var_3 -> + happyIn62 + (ColonSep happy_var_1 happy_var_3 + )}} + +happyReduce_101 = happySpecReduce_1 58# happyReduction_101 +happyReduction_101 happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn62 + (GList happy_var_1 + )} + +happyReduce_102 = happySpecReduce_1 59# happyReduction_102 +happyReduction_102 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn63 + (GWord happy_var_1 + )} + +happyReduce_103 = happyReduce 4# 59# happyReduction_103 +happyReduction_103 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + happyIn63 + (GApp happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_104 = happySpecReduce_1 59# happyReduction_104 +happyReduction_104 happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn63 + (GVar happy_var_1 + )} + +happyReduce_105 = happySpecReduce_1 59# happyReduction_105 +happyReduction_105 happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn63 + (GNumber happy_var_1 + )} + +happyReduce_106 = happySpecReduce_1 59# happyReduction_106 +happyReduction_106 happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn63 + (GDistinctObject (stripQuotes '"' happy_var_1) + )} + +happyReduce_107 = happySpecReduce_1 59# happyReduction_107 +happyReduction_107 happy_x_1 + = case happyOut64 happy_x_1 of { happy_var_1 -> + happyIn63 + (happy_var_1 + )} + +happyReduce_108 = happyReduce 4# 60# happyReduction_108 +happyReduction_108 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut102 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn64 + (GFormulaData happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_109 = happySpecReduce_2 61# happyReduction_109 +happyReduction_109 happy_x_2 + happy_x_1 + = happyIn65 + ([] + ) + +happyReduce_110 = happySpecReduce_3 61# happyReduction_110 +happyReduction_110 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut66 happy_x_2 of { happy_var_2 -> + happyIn65 + (happy_var_2 + )} + +happyReduce_111 = happySpecReduce_1 62# happyReduction_111 +happyReduction_111 happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn66 + ([happy_var_1] + )} + +happyReduce_112 = happySpecReduce_3 62# happyReduction_112 +happyReduction_112 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + happyIn66 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_113 = happySpecReduce_1 63# happyReduction_113 +happyReduction_113 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn67 + (happy_var_1 + )} + +happyReduce_114 = happySpecReduce_1 63# happyReduction_114 +happyReduction_114 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn67 + (AtomicWord(show happy_var_1) + )} + +happyReduce_115 = happySpecReduce_1 64# happyReduction_115 +happyReduction_115 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn68 + (AtomicWord happy_var_1 + )} + +happyReduce_116 = happySpecReduce_1 64# happyReduction_116 +happyReduction_116 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn68 + (AtomicWord (stripQuotes '\'' happy_var_1) + )} + +happyReduce_117 = happySpecReduce_1 65# happyReduction_117 +happyReduction_117 happy_x_1 + = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_118 = happySpecReduce_1 66# happyReduction_118 +happyReduction_118 happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn70 + (happy_var_1 + )} + +happyReduce_119 = happySpecReduce_1 67# happyReduction_119 +happyReduction_119 happy_x_1 + = case happyOut108 happy_x_1 of { happy_var_1 -> + happyIn71 + (happy_var_1 + )} + +happyReduce_120 = happySpecReduce_1 67# happyReduction_120 +happyReduction_120 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn71 + (fromIntegral happy_var_1 + )} + +happyReduce_121 = happySpecReduce_1 67# happyReduction_121 +happyReduction_121 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn71 + (fromIntegral happy_var_1 + )} + +happyReduce_122 = happySpecReduce_1 68# happyReduction_122 +happyReduction_122 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn72 + (stripQuotes '\'' happy_var_1 + )} + +happyReduce_123 = happySpecReduce_1 69# happyReduction_123 +happyReduction_123 happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn73 + (happy_var_1 + )} + +happyReduce_124 = happySpecReduce_1 69# happyReduction_124 +happyReduction_124 happy_x_1 + = happyIn73 + ("fof" + ) + +happyReduce_125 = happySpecReduce_1 69# happyReduction_125 +happyReduction_125 happy_x_1 + = happyIn73 + ("cnf" + ) + +happyReduce_126 = happySpecReduce_1 69# happyReduction_126 +happyReduction_126 happy_x_1 + = happyIn73 + ("include" + ) + +happyReduce_127 = happySpecReduce_2 70# happyReduction_127 +happyReduction_127 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn74 + (happy_var_1 + )} + +happyReduce_128 = happySpecReduce_2 71# happyReduction_128 +happyReduction_128 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn75 + (happy_var_1 + )} + +happyReduce_129 = happySpecReduce_2 72# happyReduction_129 +happyReduction_129 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn76 + (happy_var_1 + )} + +happyReduce_130 = happySpecReduce_2 73# happyReduction_130 +happyReduction_130 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn77 + (happy_var_1 + )} + +happyReduce_131 = happySpecReduce_2 74# happyReduction_131 +happyReduction_131 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn78 + (happy_var_1 + )} + +happyReduce_132 = happySpecReduce_2 75# happyReduction_132 +happyReduction_132 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn79 + (happy_var_1 + )} + +happyReduce_133 = happySpecReduce_2 76# happyReduction_133 +happyReduction_133 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn80 + (happy_var_1 + )} + +happyReduce_134 = happySpecReduce_2 77# happyReduction_134 +happyReduction_134 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn81 + (happy_var_1 + )} + +happyReduce_135 = happySpecReduce_2 78# happyReduction_135 +happyReduction_135 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn82 + (happy_var_1 + )} + +happyReduce_136 = happySpecReduce_2 79# happyReduction_136 +happyReduction_136 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + happyIn83 + (AToken happy_var_1 happy_var_2 + )}} + +happyReduce_137 = happySpecReduce_2 80# happyReduction_137 +happyReduction_137 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn84 + (happy_var_1 + )} + +happyReduce_138 = happySpecReduce_2 81# happyReduction_138 +happyReduction_138 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn85 + (happy_var_1 + )} + +happyReduce_139 = happySpecReduce_2 82# happyReduction_139 +happyReduction_139 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn86 + (happy_var_1 + )} + +happyReduce_140 = happySpecReduce_2 83# happyReduction_140 +happyReduction_140 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn87 + (happy_var_1 + )} + +happyReduce_141 = happySpecReduce_2 84# happyReduction_141 +happyReduction_141 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn88 + (happy_var_1 + )} + +happyReduce_142 = happySpecReduce_2 85# happyReduction_142 +happyReduction_142 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn89 + (happy_var_1 + )} + +happyReduce_143 = happySpecReduce_2 86# happyReduction_143 +happyReduction_143 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn90 + (happy_var_1 + )} + +happyReduce_144 = happySpecReduce_2 87# happyReduction_144 +happyReduction_144 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn91 + (happy_var_1 + )} + +happyReduce_145 = happySpecReduce_2 88# happyReduction_145 +happyReduction_145 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92 + (happy_var_1 + )} + +happyReduce_146 = happySpecReduce_2 89# happyReduction_146 +happyReduction_146 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn93 + (happy_var_1 + )} + +happyReduce_147 = happySpecReduce_2 90# happyReduction_147 +happyReduction_147 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn94 + (happy_var_1 + )} + +happyReduce_148 = happySpecReduce_2 91# happyReduction_148 +happyReduction_148 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn95 + (happy_var_1 + )} + +happyReduce_149 = happySpecReduce_2 92# happyReduction_149 +happyReduction_149 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn96 + (happy_var_1 + )} + +happyReduce_150 = happySpecReduce_2 93# happyReduction_150 +happyReduction_150 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn97 + (happy_var_1 + )} + +happyReduce_151 = happySpecReduce_2 94# happyReduction_151 +happyReduction_151 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn98 + (happy_var_1 + )} + +happyReduce_152 = happySpecReduce_2 95# happyReduction_152 +happyReduction_152 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn99 + (happy_var_1 + )} + +happyReduce_153 = happySpecReduce_2 96# happyReduction_153 +happyReduction_153 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (SingleQuoted happy_var_1) -> + happyIn100 + (happy_var_1 + )} + +happyReduce_154 = happySpecReduce_2 97# happyReduction_154 +happyReduction_154 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (DoubleQuoted happy_var_1) -> + happyIn101 + (happy_var_1 + )} + +happyReduce_155 = happySpecReduce_2 98# happyReduction_155 +happyReduction_155 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (DollarWord happy_var_1) -> + happyIn102 + (happy_var_1 + )} + +happyReduce_156 = happySpecReduce_2 99# happyReduction_156 +happyReduction_156 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (DollarDollarWord happy_var_1) -> + happyIn103 + (happy_var_1 + )} + +happyReduce_157 = happySpecReduce_2 100# happyReduction_157 +happyReduction_157 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (UpperWord happy_var_1) -> + happyIn104 + (happy_var_1 + )} + +happyReduce_158 = happySpecReduce_2 101# happyReduction_158 +happyReduction_158 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (LowerWord happy_var_1) -> + happyIn105 + (happy_var_1 + )} + +happyReduce_159 = happySpecReduce_2 102# happyReduction_159 +happyReduction_159 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (SignedInt happy_var_1) -> + happyIn106 + (happy_var_1 + )} + +happyReduce_160 = happySpecReduce_2 103# happyReduction_160 +happyReduction_160 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (UnsignedInt happy_var_1) -> + happyIn107 + (happy_var_1 + )} + +happyReduce_161 = happySpecReduce_2 104# happyReduction_161 +happyReduction_161 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (Real happy_var_1) -> + happyIn108 + (happy_var_1 + )} + +happyReduce_162 = happySpecReduce_0 105# happyReduction_162 +happyReduction_162 = happyIn109 + ([] + ) + +happyReduce_163 = happySpecReduce_2 105# happyReduction_163 +happyReduction_163 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (CommentToken happy_var_1) -> + case happyOut109 happy_x_2 of { happy_var_2 -> + happyIn109 + (happy_var_1 : happy_var_2 + )}} + +happyNewToken action sts stk [] = + happyDoAction 37# notHappyAtAll action sts stk [] + +happyNewToken action sts stk (tk:tks) = + let cont i = happyDoAction i tk action sts stk tks in + case tk of { + LP -> cont 1#; + RP -> cont 2#; + Lbrack -> cont 3#; + Rbrack -> cont 4#; + Comma -> cont 5#; + Dot -> cont 6#; + Star -> cont 7#; + Plus -> cont 8#; + Rangle -> cont 9#; + Oper ":" -> cont 10#; + Oper "<=>" -> cont 11#; + Oper "=>" -> cont 12#; + Oper "<~>" -> cont 13#; + Oper "~|" -> cont 14#; + Oper "~&" -> cont 15#; + Oper "<=" -> cont 16#; + Oper "=" -> cont 17#; + Oper "!=" -> cont 18#; + Oper "!" -> cont 19#; + Oper "?" -> cont 20#; + Oper "&" -> cont 21#; + Oper "|" -> cont 22#; + Oper "~" -> cont 23#; + LowerWord "fof" -> cont 24#; + LowerWord "cnf" -> cont 25#; + LowerWord "include" -> cont 26#; + SingleQuoted happy_dollar_dollar -> cont 27#; + DoubleQuoted happy_dollar_dollar -> cont 28#; + DollarWord happy_dollar_dollar -> cont 29#; + DollarDollarWord happy_dollar_dollar -> cont 30#; + UpperWord happy_dollar_dollar -> cont 31#; + LowerWord happy_dollar_dollar -> cont 32#; + SignedInt happy_dollar_dollar -> cont 33#; + UnsignedInt happy_dollar_dollar -> cont 34#; + Real happy_dollar_dollar -> cont 35#; + CommentToken happy_dollar_dollar -> cont 36#; + _ -> happyError' (tk:tks) + } + +happyError_ tk tks = happyError' (tk:tks) + +newtype HappyIdentity a = HappyIdentity a +happyIdentity = HappyIdentity +happyRunIdentity (HappyIdentity a) = a + +instance Monad HappyIdentity where + return = HappyIdentity + (HappyIdentity p) >>= q = q p + +happyThen :: () => HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b +happyThen = (>>=) +happyReturn :: () => a -> HappyIdentity a +happyReturn = (return) +happyThen1 m k tks = (>>=) m (\a -> k a tks) +happyReturn1 :: () => a -> b -> HappyIdentity a +happyReturn1 = \a tks -> (return) a +happyError' :: () => [(Token)] -> HappyIdentity a +happyError' = HappyIdentity . ((\xs -> case xs of + xs -> error ("Parse error, pos: "++show (take 25 xs)))) + +parseTPTPwithComment tks = happyRunIdentity happySomeParser where + happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut4 x)) + +happySeq = happyDontSeq + + +data AToken = AToken { tok :: Token, comm :: [String] } + +class Commented c where + withComments :: F c -> [String] -> F c + +instance Commented Identity where + withComments = const + +instance Commented (State [String]) where + withComments (F mf) s = F $ do { f <- mf; put s; return f } + + +stripQuotes which (x:xs) = go xs + where + go [x] = [] + go ('\\':'\\':xs) = '\\':go xs + go ('\\':which:xs) = which:go xs + go (x:xs) = x:go xs + +fApp2pApp (T mf) = F $ do FunApp x args <- mf + return $ PredApp x args +{-# LINE 1 "templates/GenericTemplate.hs" #-} +{-# LINE 1 "templates/GenericTemplate.hs" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "templates/GenericTemplate.hs" #-} +-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp + +{-# LINE 30 "templates/GenericTemplate.hs" #-} + + +data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList + + + + + +{-# LINE 51 "templates/GenericTemplate.hs" #-} + +{-# LINE 61 "templates/GenericTemplate.hs" #-} + +{-# LINE 70 "templates/GenericTemplate.hs" #-} + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- 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 + + + +happyDoAction i tk st + = {- nothing -} + + + case action of + 0# -> {- nothing -} + happyFail i tk st + -1# -> {- nothing -} + happyAccept i tk st + n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + + + happyShift new_state i tk st + where !(new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where !(off) = indexShortOffAddr happyActOffsets st + !(off_i) = (off Happy_GHC_Exts.+# i) + check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#)) + then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i) + else False + !(action) + | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + +{-# LINE 130 "templates/GenericTemplate.hs" #-} + + +indexShortOffAddr (HappyA# arr) off = + Happy_GHC_Exts.narrow16Int# i + where + !i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) + !high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + !low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + !off' = off Happy_GHC_Exts.*# 2# + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + +{-# LINE 163 "templates/GenericTemplate.hs" #-} + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let !(i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) + drop_stk = happyDropStk k stk + +happyMonad2Reduce k nt fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happyMonad2Reduce k nt fn j tk st sts stk = + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + where !(sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts)) + drop_stk = happyDropStk k stk + + !(off) = indexShortOffAddr happyGotoOffsets st1 + !(off_i) = (off Happy_GHC_Exts.+# nt) + !(new_state) = indexShortOffAddr happyTable off_i + + + + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where !(off) = indexShortOffAddr happyGotoOffsets st + !(off_i) = (off Happy_GHC_Exts.+# nt) + !(new_state) = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (0# is the error token) + +-- parse error if we are in recovery and we fail again +happyFail 0# tk old_st _ stk = +-- trace "failing" $ + 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 + for now --SDM + +-- discard a state +happyFail 0# tk old_st (HappyCons ((action)) (sts)) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail i tk (action) sts stk = +-- trace "entering error recovery" $ + happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + + +{-# NOINLINE happyDoAction #-} +{-# NOINLINE happyTable #-} +{-# NOINLINE happyCheck #-} +{-# NOINLINE happyActOffsets #-} +{-# NOINLINE happyGotoOffsets #-} +{-# NOINLINE happyDefActions #-} + +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/logic-TPTP.cabal b/logic-TPTP.cabal --- a/logic-TPTP.cabal +++ b/logic-TPTP.cabal @@ -1,5 +1,5 @@ name: logic-TPTP -version: 0.2.0.3 +version: 0.2.0.4 cabal-version: >= 1.6 build-type: Simple license: GPL @@ -72,4 +72,6 @@ other-modules: Lexer , Parser + , ParserC , Codec.TPTP.QuickCheck +