logic-TPTP 0.2.0.3 → 0.2.0.4

raw patch · 8 files changed

+3202/−133 lines, 8 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Codec/TPTP/Base.hs +69/−6
• Codec/TPTP/Import.hs +13/−5
• Codec/TPTP/Pretty.hs +58/−58
• Parser.y +22/−22
• ParserC.y +509/−0
• dist/build/Parser.hs +41/−41
• dist/build/ParserC.hs +2487/−0
• logic-TPTP.cabal +3/−1

@@ -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) 

@@ -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+

@@ -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

@@ -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 } 

@@ -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+}+

@@ -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

@@ -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 "<built-in>" #-}+{-# LINE 1 "<command-line>" #-}+{-# 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.

@@ -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+