HXQ 0.3 → 0.4
raw patch · 13 files changed
+4767/−4222 lines, 13 files
Files
- HXQ.cabal +6/−2
- Main.hs +13/−24
- Main2.hs +0/−28
- Makefile +13/−6
- Test1.hs +42/−0
- Test2.hs +28/−0
- XQuery.hs +5/−478
- XQueryCompiler.hs +506/−0
- XQueryInterpreter.hs +123/−0
- XQueryParser.hs +3984/−3673
- XQueryParser.y +14/−3
- data/q1.xq +8/−0
- index.html +25/−8
HXQ.cabal view
@@ -1,5 +1,5 @@ Name: HXQ-Version: 0.3+Version: 0.4 Description: A Compiler from XQuery to Haskell Synopsis: A Compiler from XQuery to Haskell Category: XML@@ -13,10 +13,14 @@ Makefile index.html data/cs.xml+ data/q1.xq XQuery.hs XQueryParser.hs XQueryParser.y- Main2.hs+ XQueryCompiler.hs+ XQueryInterpreter.hs+ Test1.hs+ Test2.hs hxml-0.2/Arrow.hs hxml-0.2/LLParsing.hs hxml-0.2/XML.hs
Main.hs view
@@ -1,36 +1,25 @@ {-------------------------------------------------------------- --- The main program of the XQuery processor+- The main program of the XQuery interpreter - Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)-- Date: 03/19/2008+- Date: 03/23/2008 - ---------------------------------------------------------------} {-# OPTIONS_GHC -fth #-}+ module Main where +import System.Environment import XQuery -f(d,s) = $(xe "<student dept='{$d/text()}'>{$s//firstname/text(),' ',$s//lastname/text()}</student>")--main = do a <- $(xq (" for $s in doc('data/cs.xml')//gradstudent "- ++" orderby $s/gpa descending, $s//lastname "- ++" return <student>{$s//firstname/text(),' ', "- ++" $s//lastname/text(),' ', "- ++" $s/gpa/text()}</student> "))- putStrLn (show a)- let query name = $(xq " doc('data/cs.xml')//gradstudent[.//lastname = $name]//firstname ")- b <- query $(xe " 'Galanis' ") -- or use: query [XText "Galanis"]- putStrLn (show b)- c <- $(xq (" <good-students>{ "- ++" let $d := doc('data/cs.xml') "- ++" for $s in $d//gradstudent "- ++" where $s/gpa = '4.0' "- ++" return f($d//deptname,$s) "- ++" }</good-students> "))- putStrLn (show c)- let q file = $(xq (" let $d := doc($file)//gradstudent "- ++" return ($d/../deptname,count($d)) "))- d <- q $(xe "'data/cs.xml'")- putStrLn (show d)+main = do env <- getArgs+ result <- if (length env) == 1+ then xfile (head env)+ else do let readl x = do t <- getLine+ if null t then return x else readl (x++t)+ putStrLn "Write an XQuery (finish the query with an empty line)"+ query <- readl ""+ xquery query+ putStrLn (show result)
− Main2.hs
@@ -1,28 +0,0 @@-{------------------------------------------------------------------ The main program of the XQuery processor-- Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)-- Date: 03/19/2008------------------------------------------------------------------}--{-# OPTIONS_GHC -fth #-}--module Main where--import XQuery--f(x,y) = $(xe "<a>{$x,', ',$y}</a>")--main = do a <- $(xq ("<result>{ "- ++" for $x in doc('/home/fegaras/data/dblp.xml')//inproceedings at $i "- ++" where $x/author = 'Leonidas Fegaras' "- ++" orderby $x/year descending "- ++" return <paper>{ $i, ') ', $x/booktitle/text(), "- ++" ': ', $x/title/text() "- ++" }</paper> "- ++" }</result> "))- putStrLn (show a)- b <- $(xq "f($a/paper[10],$a/paper[8])")- putStrLn (show b)-
Makefile view
@@ -1,19 +1,26 @@ hxml = hxml-0.2 options = -O-runopt = +RTS -S -RTS -xquery: XQueryParser.hs XQuery.hs Main.hs+xquery: XQueryParser.hs XQueryCompiler.hs XQueryInterpreter.hs XQuery.hs Main.hs ghc $(options) -i$(hxml) --make Main.hs -o xquery XQueryParser.hs: XQueryParser.y happy -g -c XQueryParser.y run: xquery- ./xquery $(runopt)+ ./xquery -test: XQueryParser.hs- ghci -fth -i$(hxml) XQuery.hs XQueryParser.hs+test1: xquery+ ghc -O -ihxml-0.2 --make Test1.hs -o test1+ ./test1 +test2: xquery+ ghc -O -ihxml-0.2 --make Test2.hs -o test2+ ./test2++ghci: XQueryParser.hs+ ghci -fth -i$(hxml) XQuery.hs XQueryCompiler.hs XQueryInterpreter.hs XQueryParser.hs+ clean:- /bin/rm -f *~ *.o *.hi $(hxml)/*.o $(hxml)/*.hi XQueryParser.hs *.stat *.prof *.ps *.aux *.hp xquery+ /bin/rm -f *~ *.o *.hi $(hxml)/*.o $(hxml)/*.hi XQueryParser.hs *.stat *.prof *.ps *.aux *.hp xquery test1 test2
+ Test1.hs view
@@ -0,0 +1,42 @@+{--------------------------------------------------------------+-+- The main program of the XQuery processor+- Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)+- Date: 03/19/2008+-+---------------------------------------------------------------}++{-# OPTIONS_GHC -fth #-}++module Main where++import XQuery+++f(d,s) = $(xe "<student dept='{$d/text()}'>{$s//firstname/text(),' ',$s//lastname/text()}</student>")++main = do a <- $(xq (" for $s in doc('data/cs.xml')//gradstudent "+ ++" orderby $s/gpa descending, $s//lastname "+ ++" return <student>{$s//firstname/text(),' ', "+ ++" $s//lastname/text(),' ', "+ ++" $s/gpa/text()}</student> "))+ putStrLn (show a)+ let query name = $(xq " doc('data/cs.xml')//gradstudent[.//lastname = $name]//firstname ")+ b <- query $(xe " 'Galanis' ") -- or use: query [XText "Galanis"]+ putStrLn (show b)+ c <- $(xq (" <good-students>{ "+ ++" let $d := doc('data/cs.xml') "+ ++" for $s in $d//gradstudent "+ ++" where $s/gpa = '4.0' "+ ++" return f($d//deptname,$s) "+ ++" }</good-students> "))+ putStrLn (show c)+ let q file = $(xq (" let $d := doc($file)//gradstudent "+ ++" return ($d/../deptname,count($d)) "))+ d <- q $(xe "'data/cs.xml'")+ putStrLn (show d)+ putStrLn "Type an XQuery:"+ iquery <- getLine+ e <- xquery iquery -- Use the XQuery interpreter+ putStrLn (show e)+
+ Test2.hs view
@@ -0,0 +1,28 @@+{--------------------------------------------------------------+-+- The main program of the XQuery processor+- Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)+- Date: 03/19/2008+-+---------------------------------------------------------------}++{-# OPTIONS_GHC -fth #-}++module Main where++import XQuery++f(x,y) = $(xe "<a>{$x,', ',$y}</a>")++main = do a <- $(xq ("<result>{ "+ ++" for $x in doc('/home/fegaras/data/dblp.xml')//inproceedings at $i "+ ++" where $x/author = 'Leonidas Fegaras' "+ ++" orderby $x/year descending "+ ++" return <paper>{ $i, ') ', $x/booktitle/text(), "+ ++" ': ', $x/title/text() "+ ++" }</paper> "+ ++" }</result> "))+ putStrLn (show a)+ b <- $(xq "f($a/paper[10],$a/paper[8])")+ putStrLn (show b)+
XQuery.hs view
@@ -1,10 +1,10 @@ {------------------------------------------------------------------------------------- --- A Compiler from XQuery to Haskell+- The XQuery Compiler and Interpreter - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/-- Creation: 02/15/08, last update: 03/20/08+- Creation: 03/22/08, last update: 03/23/08 - - Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved. - This material is provided as is, with absolutely no warranty expressed or implied.@@ -17,482 +17,9 @@ {-# OPTIONS_GHC -fth #-} module XQuery (- XTree(..), XSeq, xq, xe, cq+ XTree(..), XSeq, xq, xe, cq, xquery, xfile ) where -import Char(isDigit)-import List(sortBy)-import XMLParse(XMLEvent(..),parseDocument)-import HXML(AttList)-import Language.Haskell.TH-import XQueryParser--{--------------- XML Trees (rose trees) ----------------------------------------------}--type Stream = [XMLEvent]--type Tag = String--data XTree = XElem Tag AttList [XTree]- | XText String- | XInt Int- | XFloat Float- deriving Eq--type XSeq = [XTree]---showAL :: AttList -> String-showAL = foldr(\(a,v) r -> " "++a++"=\'"++v++"\'"++r) []--showXT :: XTree -> String-showXT (XElem tag al xs) = "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">"-showXT (XText text) = text-showXT (XInt n) = " "++(show n)-showXT (XFloat n) = " "++(show n)--showXS :: XSeq -> String-showXS xs = concat (map showXT xs)--instance Show XTree where- show t = showXT t----- lazily materialize the SAX stream into a DOM tree-materialize :: Stream -> XTree-materialize stream = XElem "root" [] [head (filter (\x -> case x of XElem _ _ _ -> True; _ -> False)- (fst (ml stream)))]- where m ((TextEvent t):xs) = (XText t,xs)- m ((EmptyEvent n atts):xs) = (XElem n atts [],xs)- m ((StartEvent n atts):xs) = let (el,xs') = ml xs- in (XElem n atts el,xs')- m (_:xs) = (XText "unrecognized",xs)- m [] = (XText "unrecognized",[])- ml ((EndEvent n):xs) = ([],xs)- ml xs = let (e,xs') = m xs- (el,xs'') = ml xs'- in (e:el,xs'')---{--------------- XPath Steps ---------------------------------------------------------}----- XPath step /tag or /*-child :: Tag -> XTree -> XSeq-child m x = case x of- (XElem _ _ bs) -> foldr (\b s -> case b of- (XElem k _ _) | (k==m || m=="*") -> b:s- _ -> s) [] bs- _ -> []----- XPath step //tag or //*-descendant :: Tag -> XTree -> XSeq-descendant m (x@(XElem t al cs)) | m==t || m=="*" = x:(concat (map (descendant m) cs))-descendant m (XElem t al cs) = concat (map (descendant m) cs)-descendant m _ = []----- XPath step /@attr or /@*-attribute :: Tag -> XTree -> XSeq-attribute m x = case x of- (XElem _ al _) -> foldr (\(k,v) s -> if k==m || m=="*"- then (XText v):s- else s) [] al- _ -> []----- XPath step //@attr or //@*-attributeDescendant :: Tag -> XTree -> XSeq-attributeDescendant m (x@(XElem _ al cs))- = foldr (\(k,v) s -> if k==m || m=="*"- then (XText v):s- else s)- (concat (map (attributeDescendant m) cs)) al-attributeDescendant m _ = []---{------------ Functions --------------------------------------------------------------}----- like foldr but with an index-foldir :: (a -> Int -> b -> b) -> b -> [a] -> Int -> b-foldir c n [] i = n-foldir c n (x:xs) i = c x i (foldir c n xs (i+1))--trueXT = XText "true"--toString :: XSeq -> [String]-toString xs = foldr (\x r -> case x of- XElem _ _ [XText t] -> t:r- XText t -> t:r- XInt n -> (show n):r- XFloat n -> (show n):r- _ -> r) [] xs--readNum :: String -> Maybe XTree-readNum cs = case span isDigit cs of- (n,[]) -> Just (XInt (read n))- (n,'.':rest) -> case span isDigit rest of- (k,[]) -> Just (XFloat (read (n++('.':k))))- _ -> Nothing- _ -> Nothing--toNum :: XSeq -> XSeq-toNum xs = foldr (\x r -> case x of- XElem _ _ [XText s]- -> case readNum s of- Just t -> t:r- _ -> r- XInt n -> x:r- XFloat n -> x:r- XText s -> case readNum s of- Just t -> t:r- _ -> r- _ -> r) [] xs--text :: XSeq -> XSeq-text xs = foldr (\x r -> case x of- XElem _ _ [z@(XText _)] -> z:r- XElem _ _ [z@(XInt _)] -> z:r- XElem _ _ [z@(XFloat _)] -> z:r- XText _ -> x:r- XInt _ -> x:r- XFloat _ -> x:r- _ -> r) [] xs--toFloat :: XTree -> Float-toFloat (XInt n) = fromIntegral n-toFloat (XFloat n) = n--contains :: String -> String -> Bool-contains xs ys | ((take (length ys) xs) == ys) = True-contains (_:xs) ys = contains xs ys-contains [] ys = False--distinct :: XSeq -> XSeq-distinct = foldl (\r a -> if elem a r then r else r++[a]) []--arithmetic :: (Float -> Float -> Float) -> XTree -> XTree -> XTree-arithmetic op (XInt n) (XInt m) = XInt (round (op (fromIntegral n) (fromIntegral m)))-arithmetic op (XFloat n) (XFloat m) = XFloat (op n m)-arithmetic op (XFloat n) (XInt m) = XFloat (op n (fromIntegral m))-arithmetic op (XInt n) (XFloat m) = XFloat (op (fromIntegral n) m)--compareXTrees :: XTree -> XTree -> Ordering-compareXTrees (XElem _ _ _) _ = EQ-compareXTrees _ (XElem _ _ _) = EQ-compareXTrees (XInt n) (XInt m) = compare n m-compareXTrees (XFloat n) (XInt m) = compare n (fromIntegral m)-compareXTrees (XInt n) (XFloat m) = compare (fromIntegral n) m-compareXTrees (XFloat n) (XFloat m) = compare n m-compareXTrees x y = let tx = case x of XText t -> t; XInt n -> show n; XFloat n -> show n- ty = case y of XText t -> t; XInt n -> show n; XFloat n -> show n- in compare tx ty--compareXSeqs :: Bool -> XSeq -> XSeq -> Ordering-compareXSeqs ord xs ys- = let comps = [ compareXTrees x y | x <- xs, y <- ys ]- in if ord- then if all (\x -> x == LT) comps- then LT- else if all (\x -> x == GT) comps- then GT- else EQ- else if all (\x -> x == LT) comps- then GT- else if all (\x -> x == GT) comps- then LT- else EQ---type Function = [Q Exp] -> Q Exp---- System functions: they can also be defined as Haskell functions of type (XSeq,...,XSeq) -> XSeq--- but here we make sure they are unfolded and fused with the rest of the query-functions :: [(Tag,Int,Function)]-functions = [ ( "=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, x == y ] |] ),- ( "==", 2, \[xs,ys] -> [| [ trueXT | x <- $xs, y <- $ys, x == y ] |] ),- ( "!=", 2, \[xs,ys] -> [| if null [ trueXT | x <- text $xs, y <- text $ys, x == y ] then [trueXT] else [] |] ),- ( ">", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y == GT ] |] ),- ( "<", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y == LT ] |] ),- ( ">=", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y `elem` [GT,EQ] ] |] ),- ( "<=", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y `elem` [LT,EQ] ] |] ),- ( "+", 2, \[xs,ys] -> [| [ arithmetic (+) x y | x <- toNum $xs, y <- toNum $ys ] |] ),- ( "-", 2, \[xs,ys] -> [| [ arithmetic (-) x y | x <- toNum $xs, y <- toNum $ys ] |] ),- ( "*", 2, \[xs,ys] -> [| [ arithmetic (*) x y | x <- toNum $xs, y <- toNum $ys ] |] ),- ( "div", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ),- ( "idiv", 2, \[xs,ys] -> [| [ arithmetic div x y | x <- toNum $xs, y <- toNum $ys ] |] ),- ( "uplus", 1, \[xs] -> [| [ x | x <- toNum $xs ] |] ),- ( "uminus", 1, \[xs] -> [| [ case x of XInt n -> XInt (-n); XFloat n -> XFloat (-n) | x <- toNum $xs ] |] ),- ( "and", 2, \[xs,ys] -> [| if (null $xs) || (null $ys) then [] else [trueXT] |] ),- ( "or", 2, \[xs,ys] -> [| if (null $xs) && (null $ys) then [] else [trueXT] |] ),- ( "not", 1, \[xs] -> [| if (null $xs) then [trueXT] else [] |] ),- ( "some", 1, \[xs] -> [| if (null $xs) then [] else [trueXT] |] ),- ( "count", 1, \[xs] -> [| [ XInt (length $xs) ] |] ),- ( "sum", 1, \[xs] -> [| [ XFloat (sum [ toFloat x | x <- toNum $xs ]) ] |] ),- ( "avg", 1, \[xs] -> [| let ys = $xs in [ XFloat ((sum [ toFloat x | x <- toNum ys ])- / (fromIntegral (length ys))) ] |] ),- ( "min", 1, \[xs] -> [| [ XFloat (minimum [ toFloat x | x <- toNum $xs ]) ] |] ),- ( "max", 1, \[xs] -> [| [ XFloat (maximum [ toFloat x | x <- toNum $xs ]) ] |] ),- ( "to", 2, \[xs,ys] -> [| [ XInt i | XInt n <- toNum $xs, XInt m <- toNum $ys, i <- [n..m] ] |] ),- ( "text", 1, \[xs] -> [| text $xs |] ),- ( "node", 1, \[xs] -> [| $xs |] ),- ( "empty", 0, \[] -> [| [] |] ),- ( "child", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- child tag x ] |] ),- ( "descendant", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- descendant tag x ] |] ),- ( "attribute", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- attribute tag x ] |] ),- ( "descendant_attribute", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs,- z <- attributeDescendant tag x ] |] ),- ( "if", 3, \[cs,ts,es] -> [| if null $cs then $es else $ts |] ),- ( "element", 2, \[tags,xs] -> [| [ x | tag <- toString $tags, x <- $xs,- case x of XElem t _ _ -> t==tag || tag=="*"; _ -> False ] |] ),- ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute tag x ] |] ),- ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ),- ( "concat", 2, \[xs,ys] -> [| $xs ++ $ys |] ),- ( "distinct-nodes", 1, \[xs] -> [| distinct $xs |] ),- ( "union", 2, \[xs,ys] -> [| distinct ($xs ++ $ys) |] ),- ( "intersect", 2, \[xs,ys] -> [| filter (\x -> elem x $ys) $xs |] ),- ( "except", 2, \[xs,ys] -> [| filter (\x -> not (elem x $ys)) $xs |] )- ]----- make a function call-callF :: Tag -> Function-callF fname args = case filter (\(n,_,_) -> n==fname) functions of- (_,len,f):_ -> if (length args) == len- then f args- else error ("wrong number of arguments in function call: " ++ fname)- _ -> -- otherwise, it must be a Haskell function of type (XSeq,...,XSeq) -> XSeq- let itp = foldr (\_ r -> appT r [t| XSeq |] ) (appT (tupleT (length args)) [t| XSeq |]) (tail args)- fn = sigE (varE (mkName fname))- (appT (appT arrowT itp) [t| XSeq |])- in appE fn (tupE args)---{------------ Remove Backward Steps and Optimize ------------------------------------}----- does the expression contain a $var/.. ?-parentOfVar :: Ast -> String -> Bool-parentOfVar (Ast "call" [Avar "parent",Avar x]) var = x == var-parentOfVar (Ast "let" [Avar v,s,_]) var | var == v = parentOfVar s var-parentOfVar (Ast "for" [Avar v,Avar i,s,_]) var | var == v || var == i = parentOfVar s var-parentOfVar (Ast _ args) var = or (map (\x -> parentOfVar x var) args)-parentOfVar _ _ = False----- replace $var/.. with $nvar-replaceParentOfVar :: Ast -> String -> String -> Ast-replaceParentOfVar (Ast "call" [Avar "parent",Avar x]) var nvar | x == var = Avar nvar-replaceParentOfVar (Ast "let" [Avar v,s,b]) var nvar | var == v- = Ast "let" [Avar v,replaceParentOfVar s var nvar,b]-replaceParentOfVar (Ast "for" [Avar v,Avar i,s,b]) var nvar | var == v || var == i- = Ast "for" [Avar v,Avar i,replaceParentOfVar s var nvar,b]-replaceParentOfVar (Ast f args) var nvar = Ast f (map (\x -> replaceParentOfVar x var nvar) args)-replaceParentOfVar e _ _ = e----- Rules to extract the parent of an XQuery expression--- For every XQuery x and predicates p1 ... pn and for s in [tag,*,@attr]:--- x/s[p1]...[pn]/.. -> x[s[p1]...[pn]]--- x//s[p1]...[pn]/.. -> x//*[s[p1]...[pn]]-removeParent :: Ast -> (Ast,Ast,Bool,Ast)-removeParent (Ast "predicate" [c,x])- = let (nx,cond,childp,tag) = removeParent x- in (Ast "predicate" [c,nx],cond,childp,tag)-removeParent (Ast "call" [Avar "child",tag,x])- = (Ast "call" [Avar "child",tag,Avar "."],x,True,tag)-removeParent (Ast "call" [Avar "descendant",tag,x])- = (Ast "call" [Avar "child",tag,Avar "."],- Ast "call" [Avar "descendant",Astring "*",x],True,tag)-removeParent (Ast "call" [Avar "attribute",tag,x])- = (Ast "call" [Avar "attribute",tag,Avar "."],x,False,tag)-removeParent (Ast "call" [Avar "descendant_attribute",tag,x])- = (Ast "call" [Avar "attribute",tag,Avar "."],- Ast "call" [Avar "descendant",Astring "*",x],False,tag)-removeParent e = error ("Cannot remove this parent step "++(show e))---optimize :: Ast -> Ast--- must be done bottom-up: /../..-optimize (Ast "call" [Avar "parent",Ast "call" [Avar "parent",x]])- = let nx = optimize (Ast "call" [Avar "parent",x])- in optimize (Ast "call" [Avar "parent",nx])--- get rid of a parent step-optimize (Ast "call" [Avar "parent",x])- = let (nx,cond,_,_) = removeParent x- in Ast "predicate" [optimize nx,optimize cond]--- remove $var/.. in a let-FLWOR-optimize (Ast "let" [Avar var,source,body])- | parentOfVar body var- = let (nx,cond,childp,tag) = removeParent source- in optimize (Ast "let" [Avar (var++"_parent"),Ast "predicate" [nx,cond],- Ast "let" [Avar var,- Ast "call" [if childp then Avar "child" else Avar "attribute",- tag,Avar (var++"_parent")],- replaceParentOfVar body var (var++"_parent")]])--- remove $var/.. in a for-FLWOR-optimize (Ast "for" [Avar var,Avar ivar,source,body])- | parentOfVar body var- = let (nx,cond,childp,tag) = removeParent source- in optimize (Ast "for" [Avar (var++"_parent"),Avar "$",Ast "predicate" [nx,cond],- Ast "for" [Avar var,Avar ivar,- Ast "call" [if childp then Avar "child" else Avar "attribute",- tag,Avar (var++"_parent")],- replaceParentOfVar body var (var++"_parent")]])--- needs more rules-optimize (Ast n args) = Ast n (map optimize args)-optimize e = e---{------------ Compiler ---------------------------------------------------------------}----- does the expression contain a last()?-containsLast :: Ast -> Bool-containsLast (Ast "call" [Avar "last"]) = True-containsLast (Ast f _) | elem f ["let","for","predicate"] = False-containsLast (Ast _ args) = or (map containsLast args)-containsLast _ = False----- Compile the AST e into Haskell code--- context: context node--- index: the element position in the parent sequence (=position())--- seqSize: the length of the parent sequence (=last())-compile :: Ast -> Q Exp -> Q Exp -> Q Exp -> Q Exp-compile e context index seqSize- = case e of- Avar "." -> context- Avar v -> let x = varE (mkName v)- in [| $x :: XSeq |]- Aint n -> let x = litE (IntegerL (toInteger n))- in [| [ XInt $x ] |]- Afloat n -> let x = litE (RationalL (toRational n))- in [| [ XFloat $x ] |]- Astring s -> let x = litE (StringL s)- in [| [ XText $x ] |]- Ast "doc" [Aint n] -> let d = varE (mkName ("_doc"++(show n)))- in [| [ $d ] |]- Ast "call" [Avar "position"]- -> index- Ast "call" [Avar "last"]- -> seqSize- Ast "call" ((Avar f):args)- -> callF f (map (\x -> compile x context index seqSize) args)- Ast "construction" [Astring tag,Ast "attributes" al,body]- -> let alc = foldr (\p r -> case p of- Ast "pair" [Astring a,Astring v]- -> let ac = litE (StringL a)- vc = litE (StringL v)- in [| ($ac,$vc) : $r |]- Ast "pair" [Astring a,v]- -> let ac = litE (StringL a)- vc = compile v context index seqSize- in [| ($ac,showXS $vc) : $r |])- [| [] |] al- ct = litE (StringL tag)- bc = compile body context index seqSize- in [| [ XElem $ct $alc $bc ] |]- Ast "predicate" [condition,body]- | containsLast condition -- blocking: use only when last() is used in condition- -> let c = compile condition- b = compile body context index seqSize- in [| let bl = $b- len = length bl- in foldir (\x i r -> case $(c [| [ x ] |] [| [ XInt i ] |] [| [ XInt len ] |]) of- [] -> r- [XInt n] -> if i==n then x:r else r -- indexing- _ -> x:r) [] bl 1 |]- Ast "predicate" [condition,body] -- non-blocking- -> let c = compile condition- b = compile body context index seqSize- in [| foldir (\x i r -> case $(c [| [ x ] |] [| [ XInt i ] |] seqSize) of- [] -> r- [XInt n] -> if i==n then x:r else r -- indexing- _ -> x:r) [] $b 1 |]- Ast "let" [Avar var,source,body]- -> do s <- compile source context index seqSize- b <- compile body context index seqSize- return (AppE (LamE [VarP (mkName var)] b) s)- Ast "for" [Avar var,Avar "$",source,body] -- a for-loop without an index- -> let b = compile body [| $(varE (mkName var)) |] [| [] |] [| [] |]- f = lamE [varP (mkName var)] [| \x -> $b ++ x |]- s = compile source context index seqSize- in [| foldr (\x -> $f [x]) [] $s |]- Ast "for" [Avar var,Avar ivar,source,body] -- a for-loop with an index- -> let b = compile body [| $(varE (mkName var)) |]- [| $(varE (mkName ivar)) |] [| [] |]- f = lamE [varP (mkName var)] (lamE [varP (mkName ivar)] [| \x -> $b ++ x |])- s = compile source context index seqSize- in [| foldir (\x i -> $f [x] [XInt i]) [] $s 1 |]- Ast "sortTuple" (exp:orderBys) -- prepare each FLWOR tuple for sorting- -> let res = foldl (\r a -> let ac = compile a context index seqSize- in [| $r++[text $ac] |] )- [| [ $(compile exp context index seqSize) ] |] orderBys- in [| [ $res ] |]- Ast "sort" (exp:ordList)- -> let ce = compile exp context index seqSize- ordering = foldl (\r (Avar ord)- -> let asc = if ord == "ascending"- then [| True |]- else [| False |]- in [| \(x:xs) (y:ys) -> case compareXSeqs $asc x y of- EQ -> $r xs ys- o -> o |])- [| \xs ys -> EQ |] ordList- in [| concatMap head (sortBy (\(_:xs) (_:ys) -> $ordering xs ys) ($ce::[[XSeq]])) |]- _ -> error ("Illegal XQuery "++(show e))----- collect all input documents and assign them a unique number-getDocs :: Ast -> Int -> (Ast, Int, [(Int, Ast)])-getDocs query count =- case query of- Ast "call" [Avar "doc",file]- -> (Ast "doc" [Aint count], count+1, [(count,file)])- Ast n args -> let (s,c,ns) = foldr (\a r c -> let (e,c1,n1) = getDocs a c- (s,c2,n2) = r c1- in (e:s,c2,n1++n2))- (\c -> ([],c,[])) args count- in (Ast n s,c,ns)- _ -> (query,count,[])----- compile an XQuery AST that reads XML documents-compileQuery :: Ast -> Q Exp -> Q Exp-compileQuery query context- = let (ast,_,ns) = getDocs query 0- code = compile (optimize ast) context [| [] |] [| [] |]- in foldr (\(n,file) r -> let d = lamE [varP (mkName ("_doc"++(show n)))] r- in [| do let [XText f] = $(compile (optimize file) context [| [] |] [| [] |])- doc <- readFile f- $d (materialize (parseDocument doc))- |])- [| return $code |] ns----- Display the AST and the Haskell code of an input XQuery-cq :: String -> IO ()-cq query = do putStrLn "Abstract Syntax Tree:"- let ast = parse (scan query)- putStrLn (show ast)- let opt = optimize ast- putStrLn "Optimized AST:"- putStrLn (show opt)- putStrLn "Haskell Code:"- let code = compileQuery opt [| [] |]- runQ code >>= putStrLn.pprint----- Run an XQuery expression that does not read XML documents--- When evaluated, it returns XSeq-xe :: String -> Q Exp-xe query = compile (optimize (parse (scan query))) [| [] |] [| [] |] [| [] |]-+import XQueryCompiler+import XQueryInterpreter --- Run an XQuery that reads XML documents--- When evaluated, it returns IO XSeq-xq :: String -> Q Exp-xq query = compileQuery (parse (scan query)) [| [] |]
+ XQueryCompiler.hs view
@@ -0,0 +1,506 @@+{-------------------------------------------------------------------------------------+-+- A Compiler from XQuery to Haskell+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 02/15/08, last update: 03/23/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++{-# OPTIONS_GHC -fth #-}++module XQueryCompiler where++import Char(isDigit)+import List(sortBy)+import XMLParse(XMLEvent(..),parseDocument)+import HXML(AttList)+import Language.Haskell.TH+import XQueryParser++{--------------- XML Trees (rose trees) ----------------------------------------------}++type Stream = [XMLEvent]++type Tag = String++data XTree = XElem Tag AttList [XTree]+ | XText String+ | XInt Int+ | XFloat Float+ deriving Eq++type XSeq = [XTree]+++showAL :: AttList -> String+showAL = foldr(\(a,v) r -> " "++a++"=\'"++v++"\'"++r) []++showXT :: XTree -> String+showXT (XElem tag al xs) = "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">"+showXT (XText text) = text+showXT (XInt n) = " "++(show n)+showXT (XFloat n) = " "++(show n)++showXS :: XSeq -> String+showXS xs = concat (map showXT xs)++instance Show XTree where+ show t = showXT t+++-- lazily materialize the SAX stream into a DOM tree+materialize :: Stream -> XTree+materialize stream = XElem "root" [] [head (filter (\x -> case x of XElem _ _ _ -> True; _ -> False)+ (fst (ml stream)))]+ where m ((TextEvent t):xs) = (XText t,xs)+ m ((EmptyEvent n atts):xs) = (XElem n atts [],xs)+ m ((StartEvent n atts):xs) = let (el,xs') = ml xs+ in (XElem n atts el,xs')+ m (_:xs) = (XText "unrecognized",xs)+ m [] = (XText "unrecognized",[])+ ml ((EndEvent n):xs) = ([],xs)+ ml xs = let (e,xs') = m xs+ (el,xs'') = ml xs'+ in (e:el,xs'')+++{--------------- XPath Steps ---------------------------------------------------------}+++-- XPath step /tag or /*+child :: Tag -> XTree -> XSeq+child m x = case x of+ (XElem _ _ bs) -> foldr (\b s -> case b of+ (XElem k _ _) | (k==m || m=="*") -> b:s+ _ -> s) [] bs+ _ -> []+++-- XPath step //tag or //*+descendant :: Tag -> XTree -> XSeq+descendant m (x@(XElem t al cs)) | m==t || m=="*" = x:(concat (map (descendant m) cs))+descendant m (XElem t al cs) = concat (map (descendant m) cs)+descendant m _ = []+++-- XPath step /@attr or /@*+attribute :: Tag -> XTree -> XSeq+attribute m x = case x of+ (XElem _ al _) -> foldr (\(k,v) s -> if k==m || m=="*"+ then (XText v):s+ else s) [] al+ _ -> []+++-- XPath step //@attr or //@*+attributeDescendant :: Tag -> XTree -> XSeq+attributeDescendant m (x@(XElem _ al cs))+ = foldr (\(k,v) s -> if k==m || m=="*"+ then (XText v):s+ else s)+ (concat (map (attributeDescendant m) cs)) al+attributeDescendant m _ = []+++{------------ Functions --------------------------------------------------------------}+++-- like foldr but with an index+foldir :: (a -> Int -> b -> b) -> b -> [a] -> Int -> b+foldir c n [] i = n+foldir c n (x:xs) i = c x i (foldir c n xs (i+1))++trueXT = XText "true"++toString :: XSeq -> [String]+toString xs = foldr (\x r -> case x of+ XElem _ _ [XText t] -> t:r+ XText t -> t:r+ XInt n -> (show n):r+ XFloat n -> (show n):r+ _ -> r) [] xs++readNum :: String -> Maybe XTree+readNum cs = case span isDigit cs of+ (n,[]) -> Just (XInt (read n))+ (n,'.':rest) -> case span isDigit rest of+ (k,[]) -> Just (XFloat (read (n++('.':k))))+ _ -> Nothing+ _ -> Nothing++toNum :: XSeq -> XSeq+toNum xs = foldr (\x r -> case x of+ XElem _ _ [XText s]+ -> case readNum s of+ Just t -> t:r+ _ -> r+ XInt n -> x:r+ XFloat n -> x:r+ XText s -> case readNum s of+ Just t -> t:r+ _ -> r+ _ -> r) [] xs++text :: XSeq -> XSeq+text xs = foldr (\x r -> case x of+ XElem _ _ [z@(XText _)] -> z:r+ XElem _ _ [z@(XInt _)] -> z:r+ XElem _ _ [z@(XFloat _)] -> z:r+ XText _ -> x:r+ XInt _ -> x:r+ XFloat _ -> x:r+ _ -> r) [] xs++toFloat :: XTree -> Float+toFloat (XInt n) = fromIntegral n+toFloat (XFloat n) = n++contains :: String -> String -> Bool+contains xs ys | ((take (length ys) xs) == ys) = True+contains (_:xs) ys = contains xs ys+contains [] ys = False++distinct :: XSeq -> XSeq+distinct = foldl (\r a -> if elem a r then r else r++[a]) []++arithmetic :: (Float -> Float -> Float) -> XTree -> XTree -> XTree+arithmetic op (XInt n) (XInt m) = XInt (round (op (fromIntegral n) (fromIntegral m)))+arithmetic op (XFloat n) (XFloat m) = XFloat (op n m)+arithmetic op (XFloat n) (XInt m) = XFloat (op n (fromIntegral m))+arithmetic op (XInt n) (XFloat m) = XFloat (op (fromIntegral n) m)++compareXTrees :: XTree -> XTree -> Ordering+compareXTrees (XElem _ _ _) _ = EQ+compareXTrees _ (XElem _ _ _) = EQ+compareXTrees (XInt n) (XInt m) = compare n m+compareXTrees (XFloat n) (XInt m) = compare n (fromIntegral m)+compareXTrees (XInt n) (XFloat m) = compare (fromIntegral n) m+compareXTrees (XFloat n) (XFloat m) = compare n m+compareXTrees x y = let tx = case x of XText t -> t; XInt n -> show n; XFloat n -> show n+ ty = case y of XText t -> t; XInt n -> show n; XFloat n -> show n+ in compare tx ty++compareXSeqs :: Bool -> XSeq -> XSeq -> Ordering+compareXSeqs ord xs ys+ = let comps = [ compareXTrees x y | x <- xs, y <- ys ]+ in if ord+ then if all (\x -> x == LT) comps+ then LT+ else if all (\x -> x == GT) comps+ then GT+ else EQ+ else if all (\x -> x == LT) comps+ then GT+ else if all (\x -> x == GT) comps+ then LT+ else EQ+++type Function = [Q Exp] -> Q Exp++-- System functions: they can also be defined as Haskell functions of type (XSeq,...,XSeq) -> XSeq+-- but here we make sure they are unfolded and fused with the rest of the query+functions :: [(Tag,Int,Function)]+functions = [ ( "=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, x == y ] |] ),+ ( "==", 2, \[xs,ys] -> [| [ trueXT | x <- $xs, y <- $ys, x == y ] |] ),+ ( "!=", 2, \[xs,ys] -> [| if null [ trueXT | x <- text $xs, y <- text $ys, x == y ] then [trueXT] else [] |] ),+ ( ">", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y == GT ] |] ),+ ( "<", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y == LT ] |] ),+ ( ">=", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y `elem` [GT,EQ] ] |] ),+ ( "<=", 2, \[xs,ys] -> [| [ trueXT | x <- toNum $xs, y <- toNum $ys, compareXTrees x y `elem` [LT,EQ] ] |] ),+ ( "+", 2, \[xs,ys] -> [| [ arithmetic (+) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+ ( "-", 2, \[xs,ys] -> [| [ arithmetic (-) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+ ( "*", 2, \[xs,ys] -> [| [ arithmetic (*) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+ ( "div", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+ ( "idiv", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+ ( "uplus", 1, \[xs] -> [| [ x | x <- toNum $xs ] |] ),+ ( "uminus", 1, \[xs] -> [| [ case x of XInt n -> XInt (-n); XFloat n -> XFloat (-n) | x <- toNum $xs ] |] ),+ ( "and", 2, \[xs,ys] -> [| if (null $xs) || (null $ys) then [] else [trueXT] |] ),+ ( "or", 2, \[xs,ys] -> [| if (null $xs) && (null $ys) then [] else [trueXT] |] ),+ ( "not", 1, \[xs] -> [| if (null $xs) then [trueXT] else [] |] ),+ ( "some", 1, \[xs] -> [| if (null $xs) then [] else [trueXT] |] ),+ ( "count", 1, \[xs] -> [| [ XInt (length $xs) ] |] ),+ ( "sum", 1, \[xs] -> [| [ XFloat (sum [ toFloat x | x <- toNum $xs ]) ] |] ),+ ( "avg", 1, \[xs] -> [| let ys = $xs in [ XFloat ((sum [ toFloat x | x <- toNum ys ])+ / (fromIntegral (length ys))) ] |] ),+ ( "min", 1, \[xs] -> [| [ XFloat (minimum [ toFloat x | x <- toNum $xs ]) ] |] ),+ ( "max", 1, \[xs] -> [| [ XFloat (maximum [ toFloat x | x <- toNum $xs ]) ] |] ),+ ( "to", 2, \[xs,ys] -> [| [ XInt i | XInt n <- toNum $xs, XInt m <- toNum $ys, i <- [n..m] ] |] ),+ ( "text", 1, \[xs] -> [| text $xs |] ),+ ( "node", 1, \[xs] -> [| $xs |] ),+ ( "empty", 0, \[] -> [| [] |] ),+ ( "child", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- child tag x ] |] ),+ ( "descendant", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- descendant tag x ] |] ),+ ( "attribute", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- attribute tag x ] |] ),+ ( "descendant_attribute", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs,+ z <- attributeDescendant tag x ] |] ),+ ( "if", 3, \[cs,ts,es] -> [| if null $cs then $es else $ts |] ),+ ( "element", 2, \[tags,xs] -> [| [ x | tag <- toString $tags, x <- $xs,+ case x of XElem t _ _ -> t==tag || tag=="*"; _ -> False ] |] ),+ ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute tag x ] |] ),+ ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ),+ ( "concat", 2, \[xs,ys] -> [| $xs ++ $ys |] ),+ ( "distinct-nodes", 1, \[xs] -> [| distinct $xs |] ),+ ( "union", 2, \[xs,ys] -> [| distinct ($xs ++ $ys) |] ),+ ( "intersect", 2, \[xs,ys] -> [| filter (\x -> elem x $ys) $xs |] ),+ ( "except", 2, \[xs,ys] -> [| filter (\x -> not (elem x $ys)) $xs |] )+ ]+++-- functions to be used in the interpreter+-- when evaluated, it gives [(String,Int,[XSeq]->XSeq)]+iFunctions :: Q Exp+iFunctions = foldr (\(fname,len,f) r -> let vars = map (\i -> mkName ("v_"++(show i))) [1..len]+ entry = tupE [litE (StringL fname),litE (IntegerL (toInteger len)),+ lamE [listP (map varP vars)] (f (map varE vars))]+ in [| $entry : $r |]) [| [] |] functions+++-- make a function call+callF :: Tag -> Function+callF fname args = case filter (\(n,_,_) -> n==fname) functions of+ (_,len,f):_ -> if (length args) == len+ then f args+ else error ("wrong number of arguments in function call: " ++ fname)+ _ -> -- otherwise, it must be a Haskell function of type (XSeq,...,XSeq) -> XSeq+ let itp = foldr (\_ r -> appT r [t| XSeq |] ) (appT (tupleT (length args)) [t| XSeq |]) (tail args)+ fn = sigE (varE (mkName fname))+ (appT (appT arrowT itp) [t| XSeq |])+ in appE fn (tupE args)+++{------------ Remove Backward Steps and Optimize ------------------------------------}+++-- does the expression contain a $var/.. ?+parentOfVar :: Ast -> String -> Bool+parentOfVar (Ast "call" [Avar "parent",Avar x]) var = x == var+parentOfVar (Ast "let" [Avar v,s,_]) var | var == v = parentOfVar s var+parentOfVar (Ast "for" [Avar v,Avar i,s,_]) var | var == v || var == i = parentOfVar s var+parentOfVar (Ast _ args) var = or (map (\x -> parentOfVar x var) args)+parentOfVar _ _ = False+++-- replace $var/.. with $nvar+replaceParentOfVar :: Ast -> String -> String -> Ast+replaceParentOfVar (Ast "call" [Avar "parent",Avar x]) var nvar | x == var = Avar nvar+replaceParentOfVar (Ast "let" [Avar v,s,b]) var nvar | var == v+ = Ast "let" [Avar v,replaceParentOfVar s var nvar,b]+replaceParentOfVar (Ast "for" [Avar v,Avar i,s,b]) var nvar | var == v || var == i+ = Ast "for" [Avar v,Avar i,replaceParentOfVar s var nvar,b]+replaceParentOfVar (Ast f args) var nvar = Ast f (map (\x -> replaceParentOfVar x var nvar) args)+replaceParentOfVar e _ _ = e+++-- Rules to extract the parent of an XQuery expression+-- For every XQuery x and predicates p1 ... pn and for s in [tag,*,@attr]:+-- x/s[p1]...[pn]/.. -> x[s[p1]...[pn]]+-- x//s[p1]...[pn]/.. -> x//*[s[p1]...[pn]]+removeParent :: Ast -> (Ast,Ast,Bool,Ast)+removeParent (Ast "predicate" [c,x])+ = let (nx,cond,childp,tag) = removeParent x+ in (Ast "predicate" [c,nx],cond,childp,tag)+removeParent (Ast "call" [Avar "child",tag,x])+ = (Ast "call" [Avar "child",tag,Avar "."],x,True,tag)+removeParent (Ast "call" [Avar "descendant",tag,x])+ = (Ast "call" [Avar "child",tag,Avar "."],+ Ast "call" [Avar "descendant",Astring "*",x],True,tag)+removeParent (Ast "call" [Avar "attribute",tag,x])+ = (Ast "call" [Avar "attribute",tag,Avar "."],x,False,tag)+removeParent (Ast "call" [Avar "descendant_attribute",tag,x])+ = (Ast "call" [Avar "attribute",tag,Avar "."],+ Ast "call" [Avar "descendant",Astring "*",x],False,tag)+removeParent e = error ("Cannot remove this parent step "++(show e))+++optimize :: Ast -> Ast+-- must be done bottom-up: /../..+optimize (Ast "call" [Avar "parent",Ast "call" [Avar "parent",x]])+ = let nx = optimize (Ast "call" [Avar "parent",x])+ in optimize (Ast "call" [Avar "parent",nx])+-- get rid of a parent step+optimize (Ast "call" [Avar "parent",x])+ = let (nx,cond,_,_) = removeParent x+ in Ast "predicate" [optimize nx,optimize cond]+-- remove $var/.. in a let-FLWOR+optimize (Ast "let" [Avar var,source,body])+ | parentOfVar body var+ = let (nx,cond,childp,tag) = removeParent source+ in optimize (Ast "let" [Avar (var++"_parent"),Ast "predicate" [nx,cond],+ Ast "let" [Avar var,+ Ast "call" [if childp then Avar "child" else Avar "attribute",+ tag,Avar (var++"_parent")],+ replaceParentOfVar body var (var++"_parent")]])+-- remove $var/.. in a for-FLWOR+optimize (Ast "for" [Avar var,Avar "$",source,body])+ | parentOfVar body var+ = let (nx,cond,childp,tag) = removeParent source+ in optimize (Ast "for" [Avar (var++"_parent"),Avar "$",Ast "predicate" [nx,cond],+ Ast "for" [Avar var,Avar "$",+ Ast "call" [if childp then Avar "child" else Avar "attribute",+ tag,Avar (var++"_parent")],+ replaceParentOfVar body var (var++"_parent")]])+-- needs more rules+optimize (Ast n args) = Ast n (map optimize args)+optimize e = e+++{------------ Compiler ---------------------------------------------------------------}+++-- does the expression contain a last()?+containsLast :: Ast -> Bool+containsLast (Ast "call" [Avar "last"]) = True+containsLast (Ast f _) | elem f ["let","for","predicate"] = False+containsLast (Ast _ args) = or (map containsLast args)+containsLast _ = False+++-- Compile the AST e into Haskell code+-- context: context node+-- index: the element position in the parent sequence (=position())+-- seqSize: the length of the parent sequence (=last())+compile :: Ast -> Q Exp -> Q Exp -> Q Exp -> Q Exp+compile e context index seqSize+ = case e of+ Avar "." -> context+ Avar v -> let x = varE (mkName v)+ in [| $x :: XSeq |]+ Aint n -> let x = litE (IntegerL (toInteger n))+ in [| [ XInt $x ] |]+ Afloat n -> let x = litE (RationalL (toRational n))+ in [| [ XFloat $x ] |]+ Astring s -> let x = litE (StringL s)+ in [| [ XText $x ] |]+ Ast "doc" [Aint n] -> let d = varE (mkName ("_doc"++(show n)))+ in [| [ $d ] |]+ Ast "call" [Avar "position"]+ -> index+ Ast "call" [Avar "last"]+ -> seqSize+ Ast "call" ((Avar f):args)+ -> callF f (map (\x -> compile x context index seqSize) args)+ Ast "construction" [Astring tag,Ast "attributes" al,body]+ -> let alc = foldr (\p r -> case p of+ Ast "pair" [Astring a,Astring v]+ -> let ac = litE (StringL a)+ vc = litE (StringL v)+ in [| ($ac,$vc) : $r |]+ Ast "pair" [Astring a,v]+ -> let ac = litE (StringL a)+ vc = compile v context index seqSize+ in [| ($ac,showXS $vc) : $r |])+ [| [] |] al+ ct = litE (StringL tag)+ bc = compile body context index seqSize+ in [| [ XElem $ct $alc $bc ] |]+ Ast "predicate" [condition,body]+ | containsLast condition -- blocking: use only when last() is used in condition+ -> let c = compile condition+ b = compile body context index seqSize+ in [| let bl = $b+ len = length bl+ in foldir (\x i r -> case $(c [| [ x ] |] [| [ XInt i ] |] [| [ XInt len ] |]) of+ [] -> r+ [XInt n] -> if i==n then x:r else r -- indexing+ _ -> x:r) [] bl 1 |]+ Ast "predicate" [condition,body] -- non-blocking+ -> let c = compile condition+ b = compile body context index seqSize+ in [| foldir (\x i r -> case $(c [| [ x ] |] [| [ XInt i ] |] seqSize) of+ [] -> r+ [XInt n] -> if i==n then x:r else r -- indexing+ _ -> x:r) [] $b 1 |]+ Ast "let" [Avar var,source,body]+ -> do s <- compile source context index seqSize+ b <- compile body context index seqSize+ return (AppE (LamE [VarP (mkName var)] b) s)+ Ast "for" [Avar var,Avar "$",source,body] -- a for-loop without an index+ -> let b = compile body [| $(varE (mkName var)) |] [| [] |] [| [] |]+ f = lamE [varP (mkName var)] [| \x -> $b ++ x |]+ s = compile source context index seqSize+ in [| foldr (\x -> $f [x]) [] $s |]+ Ast "for" [Avar var,Avar ivar,source,body] -- a for-loop with an index+ -> let b = compile body [| $(varE (mkName var)) |]+ [| $(varE (mkName ivar)) |] [| [] |]+ f = lamE [varP (mkName var)] (lamE [varP (mkName ivar)] [| \x -> $b ++ x |])+ s = compile source context index seqSize+ in [| foldir (\x i -> $f [x] [XInt i]) [] $s 1 |]+ Ast "sortTuple" (exp:orderBys) -- prepare each FLWOR tuple for sorting+ -> let res = foldl (\r a -> let ac = compile a context index seqSize+ in [| $r++[text $ac] |] )+ [| [ $(compile exp context index seqSize) ] |] orderBys+ in [| [ $res ] |]+ Ast "sort" (exp:ordList)+ -> let ce = compile exp context index seqSize+ ordering = foldr (\(Avar ord) r+ -> let asc = if ord == "ascending"+ then [| True |]+ else [| False |]+ in [| \(x:xs) (y:ys) -> case compareXSeqs $asc x y of+ EQ -> $r xs ys+ o -> o |])+ [| \xs ys -> EQ |] ordList+ in [| concatMap head (sortBy (\(_:xs) (_:ys) -> $ordering xs ys) ($ce::[[XSeq]])) |]+ _ -> error ("Illegal XQuery "++(show e))+++-- collect all input documents and assign them a unique number+getDocs :: Ast -> Int -> (Ast, Int, [(Int, Ast)])+getDocs query count =+ case query of+ Ast "call" [Avar "doc",file]+ -> (Ast "doc" [Aint count], count+1, [(count,file)])+ Ast n args -> let (s,c,ns) = foldr (\a r c -> let (e,c1,n1) = getDocs a c+ (s,c2,n2) = r c1+ in (e:s,c2,n1++n2))+ (\c -> ([],c,[])) args count+ in (Ast n s,c,ns)+ _ -> (query,count,[])+++-- compile an XQuery AST that reads XML documents+compileQuery :: Ast -> Q Exp -> Q Exp+compileQuery query context+ = let (ast,_,ns) = getDocs query 0+ code = compile (optimize ast) context [| [] |] [| [] |]+ in foldr (\(n,file) r -> let d = lamE [varP (mkName ("_doc"++(show n)))] r+ in [| do let [XText f] = $(compile (optimize file) context [| [] |] [| [] |])+ doc <- readFile f+ $d (materialize (parseDocument doc))+ |])+ [| return $code |] ns+++-- Display the AST and the Haskell code of an input XQuery+cq :: String -> IO ()+cq query = do putStrLn "Abstract Syntax Tree:"+ let ast = parse (scan query)+ putStrLn (show ast)+ let opt = optimize (last ast)+ putStrLn "Optimized AST:"+ putStrLn (show opt)+ putStrLn "Haskell Code:"+ let code = compileQuery opt [| [] |]+ runQ code >>= putStrLn.pprint+++-- Run an XQuery expression that does not read XML documents+-- When evaluated, it returns XSeq+xe :: String -> Q Exp+xe query = compile (optimize (last (parse (scan query)))) [| [] |] [| [] |] [| [] |]+++-- Run an XQuery that reads XML documents+-- When evaluated, it returns IO XSeq+xq :: String -> Q Exp+xq query = compileQuery (last (parse (scan query))) [| [] |]+
+ XQueryInterpreter.hs view
@@ -0,0 +1,123 @@+{-------------------------------------------------------------------------------------+-+- The XQuery Interpreter+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 03/22/08, last update: 03/23/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++{-# OPTIONS_GHC -fth #-}++module XQueryInterpreter where++import List(sortBy)+import XMLParse(parseDocument)+import XQueryParser+import XQueryCompiler+++systemFunctions :: [(String,Int,[XSeq]->XSeq)]+systemFunctions = $(iFunctions)++type Environment = [(String,XSeq)]++-- user-defined function: (fname,parameters,body)+type Functions = [(String,[String],Ast)]+++findV var env+ = case filter (\(n,_) -> n==var) env of+ (_,b):_ -> b+ _ -> error ("Undefined variable: "++var)+++eval :: Ast -> Environment -> Functions -> XSeq+eval e env fncs+ = case e of+ Avar v -> findV v env+ Aint n -> [ XInt n ]+ Afloat n -> [ XFloat n ]+ Astring s -> [ XText s ]+ Ast "doc" [Aint n] -> findV ("_doc"++(show n)) env+ Ast "call" [Avar "position"] -> findV "_position" env+ Ast "call" [Avar "last"] -> findV "_last" env+ Ast "call" ((Avar fname):args)+ -> case filter (\(n,_,_) -> n==fname) systemFunctions of+ [(_,len,f)] -> if (length args) == len+ then f (map (\x -> eval x env fncs) args)+ else error ("Wrong number of arguments in system call: "++fname)+ _ -> case filter (\(n,_,_) -> n==fname) fncs of+ [(_,params,body)] -> if (length params) == (length args)+ then eval body ((map (\(p,a) -> (p,eval a env fncs))+ (zip params args))++env) fncs+ else error ("Wrong number of arguments in function call: "++fname)+ _ -> error ("Undefined function: "++fname)+ Ast "construction" [Astring tag,Ast "attributes" al,body]+ -> let alc = map (\p -> case p of+ Ast "pair" [Astring a,Astring v]+ -> (a,v)+ Ast "pair" [Astring a,v]+ -> (a,show (eval v env fncs))) al+ in [ XElem tag alc (eval body env fncs) ]+ Ast "predicate" [condition,body]+ | containsLast condition -- blocking: use only when last() is used in condition+ -> let bl = eval body env fncs+ len = length bl+ in foldir (\x i r -> case eval condition ((".",[ x ]):("_position",[ XInt i ])+ :("_last",[ XInt len ]):env) fncs of+ [] -> r+ [XInt n] -> if i==n then x:r else r -- indexing+ _ -> x:r) [] bl 1+ Ast "predicate" [condition,body] -- non-blocking+ -> foldir (\x i r -> case eval condition ((".",[ x ]):("_position",[ XInt i ]):env) fncs of+ [] -> r+ [XInt n] -> if i==n then x:r else r -- indexing+ _ -> x:r) [] (eval body env fncs) 1+ Ast "let" [Avar var,source,body]+ -> eval body ((var,eval source env fncs):env) fncs+ Ast "for" [Avar var,Avar "$",source,body] -- a for-loop without an index+ -> foldr (\a r -> (eval body ((var,[a]):env) fncs)++r) [] (eval source env fncs)+ Ast "for" [Avar var,Avar ivar,source,body] -- a for-loop with an index+ -> foldir (\a i r -> (eval body ((var,[a]):(ivar,[XInt i]):env) fncs)++r)+ [] (eval source env fncs) 1+ Ast "sortTuple" (exp:orderBys) -- prepare each FLWOR tuple for sorting+ -> [ XElem "" [] (foldl (\r a -> r++[XElem "" [] (text (eval a env fncs))])+ [XElem "" [] (eval exp env fncs)] orderBys) ]+ Ast "sort" (exp:ordList)+ -> let ce = map (\(XElem "" [] xs) -> map (\(XElem "" [] ys) -> ys) xs) (eval exp env fncs)+ ordering = foldr (\(Avar ord) r (x:xs) (y:ys) -> case compareXSeqs (ord == "ascending") x y of+ EQ -> r xs ys+ o -> o)+ (\xs ys -> EQ) ordList+ in concatMap head (sortBy (\(_:xs) (_:ys) -> ordering xs ys) ce)+ _ -> error ("Illegal XQuery "++(show e))+++-- the XQuery interpreter+xquery :: String -> IO XSeq+xquery query+ = do let asts = parse (scan query)+ fncs = foldr (\e r -> case e of+ Ast "define" ((Avar f):b:args) -> (f,map (\(Avar v) -> v) args,optimize b):r+ _ -> r) [] asts + (ast,_,ns) = getDocs (last asts) 0+ env <- foldr (\(n,Astring file) r -> do doc <- readFile file+ env <- r+ return (("_doc"++(show n),[materialize (parseDocument doc)]):env))+ (return []) ns+ return (eval (optimize ast) env fncs)+++-- Read an XQuery fom a file and run it+xfile :: String -> IO XSeq+xfile file = do query <- readFile file+ xquery query+
XQueryParser.hs view
@@ -9,3679 +9,3990 @@ -- parser produced by Happy Version 1.17 -newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = GHC.Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn4 x = unsafeCoerce# x-{-# INLINE happyIn4 #-}-happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t4-happyOut4 x = unsafeCoerce# x-{-# INLINE happyOut4 #-}-happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn5 x = unsafeCoerce# x-{-# INLINE happyIn5 #-}-happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t5-happyOut5 x = unsafeCoerce# x-{-# INLINE happyOut5 #-}-happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn6 x = unsafeCoerce# x-{-# INLINE happyIn6 #-}-happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t6-happyOut6 x = unsafeCoerce# x-{-# INLINE happyOut6 #-}-happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn7 x = unsafeCoerce# x-{-# INLINE happyIn7 #-}-happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t7-happyOut7 x = unsafeCoerce# x-{-# INLINE happyOut7 #-}-happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn8 x = unsafeCoerce# x-{-# INLINE happyIn8 #-}-happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t8-happyOut8 x = unsafeCoerce# x-{-# INLINE happyOut8 #-}-happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn9 x = unsafeCoerce# x-{-# INLINE happyIn9 #-}-happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t9-happyOut9 x = unsafeCoerce# x-{-# INLINE happyOut9 #-}-happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn10 x = unsafeCoerce# x-{-# INLINE happyIn10 #-}-happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t10-happyOut10 x = unsafeCoerce# x-{-# INLINE happyOut10 #-}-happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn11 x = unsafeCoerce# x-{-# INLINE happyIn11 #-}-happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t11-happyOut11 x = unsafeCoerce# x-{-# INLINE happyOut11 #-}-happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn12 x = unsafeCoerce# x-{-# INLINE happyIn12 #-}-happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t12-happyOut12 x = unsafeCoerce# x-{-# INLINE happyOut12 #-}-happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn13 x = unsafeCoerce# x-{-# INLINE happyIn13 #-}-happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t13-happyOut13 x = unsafeCoerce# x-{-# INLINE happyOut13 #-}-happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn14 x = unsafeCoerce# x-{-# INLINE happyIn14 #-}-happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t14-happyOut14 x = unsafeCoerce# x-{-# INLINE happyOut14 #-}-happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn15 x = unsafeCoerce# x-{-# INLINE happyIn15 #-}-happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t15-happyOut15 x = unsafeCoerce# x-{-# INLINE happyOut15 #-}-happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn16 x = unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t16-happyOut16 x = unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn17 x = unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t17-happyOut17 x = unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn18 x = unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t18-happyOut18 x = unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn19 x = unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t19-happyOut19 x = unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn20 x = unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t20-happyOut20 x = unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn21 x = unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t21-happyOut21 x = unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn22 x = unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t22-happyOut22 x = unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn23 x = unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t23-happyOut23 x = unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn24 x = unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t24-happyOut24 x = unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyIn25 x = unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> t25-happyOut25 x = unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyInTok :: Token -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25)-happyInTok x = unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25) -> Token-happyOutTok x = unsafeCoerce# x-{-# INLINE happyOutTok #-}---action_0 (27#) = happyShift action_12-action_0 (28#) = happyShift action_13-action_0 (29#) = happyShift action_14-action_0 (34#) = happyShift action_15-action_0 (41#) = happyShift action_16-action_0 (42#) = happyShift action_17-action_0 (43#) = happyShift action_18-action_0 (49#) = happyShift action_19-action_0 (55#) = happyShift action_20-action_0 (59#) = happyShift action_21-action_0 (60#) = happyShift action_22-action_0 (68#) = happyShift action_23-action_0 (69#) = happyShift action_24-action_0 (73#) = happyShift action_25-action_0 (75#) = happyShift action_26-action_0 (78#) = happyShift action_27-action_0 (79#) = happyShift action_28-action_0 (81#) = happyShift action_29-action_0 (82#) = happyShift action_30-action_0 (83#) = happyShift action_31-action_0 (4#) = happyGoto action_32-action_0 (5#) = happyGoto action_2-action_0 (6#) = happyGoto action_3-action_0 (8#) = happyGoto action_4-action_0 (15#) = happyGoto action_5-action_0 (16#) = happyGoto action_6-action_0 (17#) = happyGoto action_7-action_0 (20#) = happyGoto action_8-action_0 (23#) = happyGoto action_9-action_0 (24#) = happyGoto action_10-action_0 (25#) = happyGoto action_11-action_0 x = happyTcHack x happyFail--action_1 (27#) = happyShift action_12-action_1 (28#) = happyShift action_13-action_1 (29#) = happyShift action_14-action_1 (34#) = happyShift action_15-action_1 (41#) = happyShift action_16-action_1 (42#) = happyShift action_17-action_1 (43#) = happyShift action_18-action_1 (49#) = happyShift action_19-action_1 (55#) = happyShift action_20-action_1 (59#) = happyShift action_21-action_1 (60#) = happyShift action_22-action_1 (68#) = happyShift action_23-action_1 (69#) = happyShift action_24-action_1 (73#) = happyShift action_25-action_1 (75#) = happyShift action_26-action_1 (78#) = happyShift action_27-action_1 (79#) = happyShift action_28-action_1 (81#) = happyShift action_29-action_1 (82#) = happyShift action_30-action_1 (83#) = happyShift action_31-action_1 (5#) = happyGoto action_2-action_1 (6#) = happyGoto action_3-action_1 (8#) = happyGoto action_4-action_1 (15#) = happyGoto action_5-action_1 (16#) = happyGoto action_6-action_1 (17#) = happyGoto action_7-action_1 (20#) = happyGoto action_8-action_1 (23#) = happyGoto action_9-action_1 (24#) = happyGoto action_10-action_1 (25#) = happyGoto action_11-action_1 x = happyTcHack x happyFail--action_2 x = happyTcHack x happyReduce_91--action_3 (40#) = happyShift action_61-action_3 (41#) = happyShift action_62-action_3 (42#) = happyShift action_63-action_3 (43#) = happyShift action_64-action_3 (44#) = happyShift action_65-action_3 (45#) = happyShift action_66-action_3 (46#) = happyShift action_67-action_3 (47#) = happyShift action_68-action_3 (48#) = happyShift action_69-action_3 (49#) = happyShift action_70-action_3 (50#) = happyShift action_71-action_3 (51#) = happyShift action_72-action_3 (52#) = happyShift action_73-action_3 (53#) = happyShift action_74-action_3 (54#) = happyShift action_75-action_3 (55#) = happyShift action_76-action_3 (56#) = happyShift action_77-action_3 (57#) = happyShift action_78-action_3 (58#) = happyShift action_79-action_3 x = happyTcHack x happyReduce_1--action_4 (59#) = happyShift action_58-action_4 (60#) = happyShift action_59-action_4 (64#) = happyShift action_60-action_4 (11#) = happyGoto action_57-action_4 x = happyTcHack x happyReduce_48--action_5 x = happyTcHack x happyReduce_9--action_6 x = happyTcHack x happyReduce_8--action_7 (51#) = happyShift action_55-action_7 (71#) = happyShift action_56-action_7 x = happyTcHack x happyFail--action_8 x = happyTcHack x happyReduce_7--action_9 (32#) = happyShift action_53-action_9 (74#) = happyShift action_54-action_9 (21#) = happyGoto action_51-action_9 (22#) = happyGoto action_52-action_9 x = happyTcHack x happyReduce_75--action_10 x = happyTcHack x happyReduce_86--action_11 x = happyTcHack x happyReduce_88--action_12 (79#) = happyShift action_28-action_12 (5#) = happyGoto action_39-action_12 (9#) = happyGoto action_50-action_12 x = happyTcHack x happyFail--action_13 (79#) = happyShift action_28-action_13 (5#) = happyGoto action_39-action_13 (9#) = happyGoto action_49-action_13 x = happyTcHack x happyFail--action_14 (27#) = happyShift action_12-action_14 (28#) = happyShift action_13-action_14 (29#) = happyShift action_14-action_14 (34#) = happyShift action_15-action_14 (41#) = happyShift action_16-action_14 (42#) = happyShift action_17-action_14 (43#) = happyShift action_18-action_14 (49#) = happyShift action_19-action_14 (55#) = happyShift action_20-action_14 (59#) = happyShift action_21-action_14 (60#) = happyShift action_22-action_14 (68#) = happyShift action_23-action_14 (69#) = happyShift action_24-action_14 (73#) = happyShift action_25-action_14 (75#) = happyShift action_26-action_14 (78#) = happyShift action_27-action_14 (79#) = happyShift action_28-action_14 (81#) = happyShift action_29-action_14 (82#) = happyShift action_30-action_14 (83#) = happyShift action_31-action_14 (5#) = happyGoto action_2-action_14 (6#) = happyGoto action_48-action_14 (8#) = happyGoto action_4-action_14 (15#) = happyGoto action_5-action_14 (16#) = happyGoto action_6-action_14 (17#) = happyGoto action_7-action_14 (20#) = happyGoto action_8-action_14 (23#) = happyGoto action_9-action_14 (24#) = happyGoto action_10-action_14 (25#) = happyGoto action_11-action_14 x = happyTcHack x happyFail--action_15 (27#) = happyShift action_12-action_15 (28#) = happyShift action_13-action_15 (29#) = happyShift action_14-action_15 (34#) = happyShift action_15-action_15 (35#) = happyShift action_47-action_15 (41#) = happyShift action_16-action_15 (42#) = happyShift action_17-action_15 (43#) = happyShift action_18-action_15 (49#) = happyShift action_19-action_15 (55#) = happyShift action_20-action_15 (59#) = happyShift action_21-action_15 (60#) = happyShift action_22-action_15 (68#) = happyShift action_23-action_15 (69#) = happyShift action_24-action_15 (73#) = happyShift action_25-action_15 (75#) = happyShift action_26-action_15 (78#) = happyShift action_27-action_15 (79#) = happyShift action_28-action_15 (81#) = happyShift action_29-action_15 (82#) = happyShift action_30-action_15 (83#) = happyShift action_31-action_15 (5#) = happyGoto action_2-action_15 (6#) = happyGoto action_45-action_15 (7#) = happyGoto action_46-action_15 (8#) = happyGoto action_4-action_15 (15#) = happyGoto action_5-action_15 (16#) = happyGoto action_6-action_15 (17#) = happyGoto action_7-action_15 (20#) = happyGoto action_8-action_15 (23#) = happyGoto action_9-action_15 (24#) = happyGoto action_10-action_15 (25#) = happyGoto action_11-action_15 x = happyTcHack x happyFail--action_16 (27#) = happyShift action_12-action_16 (28#) = happyShift action_13-action_16 (29#) = happyShift action_14-action_16 (34#) = happyShift action_15-action_16 (41#) = happyShift action_16-action_16 (42#) = happyShift action_17-action_16 (43#) = happyShift action_18-action_16 (49#) = happyShift action_19-action_16 (55#) = happyShift action_20-action_16 (59#) = happyShift action_21-action_16 (60#) = happyShift action_22-action_16 (68#) = happyShift action_23-action_16 (69#) = happyShift action_24-action_16 (73#) = happyShift action_25-action_16 (75#) = happyShift action_26-action_16 (78#) = happyShift action_27-action_16 (79#) = happyShift action_28-action_16 (81#) = happyShift action_29-action_16 (82#) = happyShift action_30-action_16 (83#) = happyShift action_31-action_16 (5#) = happyGoto action_2-action_16 (6#) = happyGoto action_44-action_16 (8#) = happyGoto action_4-action_16 (15#) = happyGoto action_5-action_16 (16#) = happyGoto action_6-action_16 (17#) = happyGoto action_7-action_16 (20#) = happyGoto action_8-action_16 (23#) = happyGoto action_9-action_16 (24#) = happyGoto action_10-action_16 (25#) = happyGoto action_11-action_16 x = happyTcHack x happyFail--action_17 (27#) = happyShift action_12-action_17 (28#) = happyShift action_13-action_17 (29#) = happyShift action_14-action_17 (34#) = happyShift action_15-action_17 (41#) = happyShift action_16-action_17 (42#) = happyShift action_17-action_17 (43#) = happyShift action_18-action_17 (49#) = happyShift action_19-action_17 (55#) = happyShift action_20-action_17 (59#) = happyShift action_21-action_17 (60#) = happyShift action_22-action_17 (68#) = happyShift action_23-action_17 (69#) = happyShift action_24-action_17 (73#) = happyShift action_25-action_17 (75#) = happyShift action_26-action_17 (78#) = happyShift action_27-action_17 (79#) = happyShift action_28-action_17 (81#) = happyShift action_29-action_17 (82#) = happyShift action_30-action_17 (83#) = happyShift action_31-action_17 (5#) = happyGoto action_2-action_17 (6#) = happyGoto action_43-action_17 (8#) = happyGoto action_4-action_17 (15#) = happyGoto action_5-action_17 (16#) = happyGoto action_6-action_17 (17#) = happyGoto action_7-action_17 (20#) = happyGoto action_8-action_17 (23#) = happyGoto action_9-action_17 (24#) = happyGoto action_10-action_17 (25#) = happyGoto action_11-action_17 x = happyTcHack x happyFail--action_18 x = happyTcHack x happyReduce_89--action_19 (75#) = happyShift action_42-action_19 x = happyTcHack x happyFail--action_20 (27#) = happyShift action_12-action_20 (28#) = happyShift action_13-action_20 (29#) = happyShift action_14-action_20 (34#) = happyShift action_15-action_20 (41#) = happyShift action_16-action_20 (42#) = happyShift action_17-action_20 (43#) = happyShift action_18-action_20 (49#) = happyShift action_19-action_20 (55#) = happyShift action_20-action_20 (59#) = happyShift action_21-action_20 (60#) = happyShift action_22-action_20 (68#) = happyShift action_23-action_20 (69#) = happyShift action_24-action_20 (73#) = happyShift action_25-action_20 (75#) = happyShift action_26-action_20 (78#) = happyShift action_27-action_20 (79#) = happyShift action_28-action_20 (81#) = happyShift action_29-action_20 (82#) = happyShift action_30-action_20 (83#) = happyShift action_31-action_20 (5#) = happyGoto action_2-action_20 (6#) = happyGoto action_41-action_20 (8#) = happyGoto action_4-action_20 (15#) = happyGoto action_5-action_20 (16#) = happyGoto action_6-action_20 (17#) = happyGoto action_7-action_20 (20#) = happyGoto action_8-action_20 (23#) = happyGoto action_9-action_20 (24#) = happyGoto action_10-action_20 (25#) = happyGoto action_11-action_20 x = happyTcHack x happyFail--action_21 (79#) = happyShift action_28-action_21 (5#) = happyGoto action_39-action_21 (9#) = happyGoto action_40-action_21 x = happyTcHack x happyFail--action_22 (79#) = happyShift action_28-action_22 (5#) = happyGoto action_37-action_22 (10#) = happyGoto action_38-action_22 x = happyTcHack x happyFail--action_23 (34#) = happyShift action_36-action_23 x = happyTcHack x happyFail--action_24 (34#) = happyShift action_35-action_24 x = happyTcHack x happyFail--action_25 (34#) = happyShift action_15-action_25 (43#) = happyShift action_18-action_25 (75#) = happyShift action_26-action_25 (78#) = happyShift action_27-action_25 (79#) = happyShift action_28-action_25 (5#) = happyGoto action_2-action_25 (23#) = happyGoto action_34-action_25 (24#) = happyGoto action_10-action_25 (25#) = happyGoto action_11-action_25 x = happyTcHack x happyFail--action_26 (34#) = happyShift action_33-action_26 x = happyTcHack x happyReduce_90--action_27 x = happyTcHack x happyReduce_92--action_28 x = happyTcHack x happyReduce_2--action_29 x = happyTcHack x happyReduce_33--action_30 x = happyTcHack x happyReduce_34--action_31 x = happyTcHack x happyReduce_32--action_32 (84#) = happyAccept-action_32 x = happyTcHack x happyFail--action_33 (27#) = happyShift action_12-action_33 (28#) = happyShift action_13-action_33 (29#) = happyShift action_14-action_33 (34#) = happyShift action_15-action_33 (35#) = happyShift action_131-action_33 (41#) = happyShift action_16-action_33 (42#) = happyShift action_17-action_33 (43#) = happyShift action_18-action_33 (49#) = happyShift action_19-action_33 (55#) = happyShift action_20-action_33 (59#) = happyShift action_21-action_33 (60#) = happyShift action_22-action_33 (68#) = happyShift action_23-action_33 (69#) = happyShift action_24-action_33 (73#) = happyShift action_25-action_33 (75#) = happyShift action_26-action_33 (78#) = happyShift action_27-action_33 (79#) = happyShift action_28-action_33 (81#) = happyShift action_29-action_33 (82#) = happyShift action_30-action_33 (83#) = happyShift action_31-action_33 (5#) = happyGoto action_2-action_33 (6#) = happyGoto action_45-action_33 (7#) = happyGoto action_130-action_33 (8#) = happyGoto action_4-action_33 (15#) = happyGoto action_5-action_33 (16#) = happyGoto action_6-action_33 (17#) = happyGoto action_7-action_33 (20#) = happyGoto action_8-action_33 (23#) = happyGoto action_9-action_33 (24#) = happyGoto action_10-action_33 (25#) = happyGoto action_11-action_33 x = happyTcHack x happyFail--action_34 (32#) = happyShift action_53-action_34 (74#) = happyShift action_54-action_34 (21#) = happyGoto action_129-action_34 (22#) = happyGoto action_52-action_34 x = happyTcHack x happyReduce_76--action_35 (75#) = happyShift action_128-action_35 x = happyTcHack x happyFail--action_36 (75#) = happyShift action_127-action_36 x = happyTcHack x happyFail--action_37 (63#) = happyShift action_126-action_37 x = happyTcHack x happyFail--action_38 (62#) = happyShift action_125-action_38 x = happyTcHack x happyReduce_38--action_39 (61#) = happyShift action_124-action_39 x = happyTcHack x happyFail--action_40 (62#) = happyShift action_116-action_40 x = happyTcHack x happyReduce_37--action_41 x = happyTcHack x happyReduce_31--action_42 (75#) = happyShift action_123-action_42 (19#) = happyGoto action_122-action_42 x = happyTcHack x happyReduce_61--action_43 x = happyTcHack x happyReduce_30--action_44 x = happyTcHack x happyReduce_29--action_45 (40#) = happyShift action_61-action_45 (41#) = happyShift action_62-action_45 (42#) = happyShift action_63-action_45 (43#) = happyShift action_64-action_45 (44#) = happyShift action_65-action_45 (45#) = happyShift action_66-action_45 (46#) = happyShift action_67-action_45 (47#) = happyShift action_68-action_45 (48#) = happyShift action_69-action_45 (49#) = happyShift action_70-action_45 (50#) = happyShift action_71-action_45 (51#) = happyShift action_72-action_45 (52#) = happyShift action_73-action_45 (53#) = happyShift action_74-action_45 (54#) = happyShift action_75-action_45 (55#) = happyShift action_76-action_45 (56#) = happyShift action_77-action_45 (57#) = happyShift action_78-action_45 (58#) = happyShift action_79-action_45 x = happyTcHack x happyReduce_35--action_46 (35#) = happyShift action_120-action_46 (62#) = happyShift action_121-action_46 x = happyTcHack x happyFail--action_47 x = happyTcHack x happyReduce_94--action_48 (30#) = happyShift action_119-action_48 (40#) = happyShift action_61-action_48 (41#) = happyShift action_62-action_48 (42#) = happyShift action_63-action_48 (43#) = happyShift action_64-action_48 (44#) = happyShift action_65-action_48 (45#) = happyShift action_66-action_48 (46#) = happyShift action_67-action_48 (47#) = happyShift action_68-action_48 (48#) = happyShift action_69-action_48 (49#) = happyShift action_70-action_48 (50#) = happyShift action_71-action_48 (51#) = happyShift action_72-action_48 (52#) = happyShift action_73-action_48 (53#) = happyShift action_74-action_48 (54#) = happyShift action_75-action_48 (55#) = happyShift action_76-action_48 (56#) = happyShift action_77-action_48 (57#) = happyShift action_78-action_48 (58#) = happyShift action_79-action_48 x = happyTcHack x happyFail--action_49 (62#) = happyShift action_116-action_49 (72#) = happyShift action_118-action_49 x = happyTcHack x happyFail--action_50 (62#) = happyShift action_116-action_50 (72#) = happyShift action_117-action_50 x = happyTcHack x happyFail--action_51 (74#) = happyShift action_54-action_51 (22#) = happyGoto action_115-action_51 x = happyTcHack x happyReduce_77--action_52 x = happyTcHack x happyReduce_79--action_53 (27#) = happyShift action_12-action_53 (28#) = happyShift action_13-action_53 (29#) = happyShift action_14-action_53 (34#) = happyShift action_15-action_53 (41#) = happyShift action_16-action_53 (42#) = happyShift action_17-action_53 (43#) = happyShift action_18-action_53 (49#) = happyShift action_19-action_53 (55#) = happyShift action_20-action_53 (59#) = happyShift action_21-action_53 (60#) = happyShift action_22-action_53 (68#) = happyShift action_23-action_53 (69#) = happyShift action_24-action_53 (73#) = happyShift action_25-action_53 (75#) = happyShift action_26-action_53 (78#) = happyShift action_27-action_53 (79#) = happyShift action_28-action_53 (81#) = happyShift action_29-action_53 (82#) = happyShift action_30-action_53 (83#) = happyShift action_31-action_53 (5#) = happyGoto action_2-action_53 (6#) = happyGoto action_114-action_53 (8#) = happyGoto action_4-action_53 (15#) = happyGoto action_5-action_53 (16#) = happyGoto action_6-action_53 (17#) = happyGoto action_7-action_53 (20#) = happyGoto action_8-action_53 (23#) = happyGoto action_9-action_53 (24#) = happyGoto action_10-action_53 (25#) = happyGoto action_11-action_53 x = happyTcHack x happyFail--action_54 (34#) = happyShift action_15-action_54 (43#) = happyShift action_18-action_54 (73#) = happyShift action_111-action_54 (74#) = happyShift action_112-action_54 (75#) = happyShift action_26-action_54 (77#) = happyShift action_113-action_54 (78#) = happyShift action_27-action_54 (79#) = happyShift action_28-action_54 (5#) = happyGoto action_2-action_54 (23#) = happyGoto action_110-action_54 (24#) = happyGoto action_10-action_54 (25#) = happyGoto action_11-action_54 x = happyTcHack x happyFail--action_55 (36#) = happyShift action_106-action_55 (49#) = happyShift action_19-action_55 (70#) = happyShift action_107-action_55 (80#) = happyShift action_108-action_55 (83#) = happyShift action_109-action_55 (16#) = happyGoto action_104-action_55 (17#) = happyGoto action_7-action_55 (18#) = happyGoto action_105-action_55 x = happyTcHack x happyFail--action_56 x = happyTcHack x happyReduce_60--action_57 (65#) = happyShift action_103-action_57 (12#) = happyGoto action_102-action_57 x = happyTcHack x happyReduce_50--action_58 (79#) = happyShift action_28-action_58 (5#) = happyGoto action_39-action_58 (9#) = happyGoto action_101-action_58 x = happyTcHack x happyFail--action_59 (79#) = happyShift action_28-action_59 (5#) = happyGoto action_37-action_59 (10#) = happyGoto action_100-action_59 x = happyTcHack x happyFail--action_60 (27#) = happyShift action_12-action_60 (28#) = happyShift action_13-action_60 (29#) = happyShift action_14-action_60 (34#) = happyShift action_15-action_60 (41#) = happyShift action_16-action_60 (42#) = happyShift action_17-action_60 (43#) = happyShift action_18-action_60 (49#) = happyShift action_19-action_60 (55#) = happyShift action_20-action_60 (59#) = happyShift action_21-action_60 (60#) = happyShift action_22-action_60 (68#) = happyShift action_23-action_60 (69#) = happyShift action_24-action_60 (73#) = happyShift action_25-action_60 (75#) = happyShift action_26-action_60 (78#) = happyShift action_27-action_60 (79#) = happyShift action_28-action_60 (81#) = happyShift action_29-action_60 (82#) = happyShift action_30-action_60 (83#) = happyShift action_31-action_60 (5#) = happyGoto action_2-action_60 (6#) = happyGoto action_99-action_60 (8#) = happyGoto action_4-action_60 (15#) = happyGoto action_5-action_60 (16#) = happyGoto action_6-action_60 (17#) = happyGoto action_7-action_60 (20#) = happyGoto action_8-action_60 (23#) = happyGoto action_9-action_60 (24#) = happyGoto action_10-action_60 (25#) = happyGoto action_11-action_60 x = happyTcHack x happyFail--action_61 (27#) = happyShift action_12-action_61 (28#) = happyShift action_13-action_61 (29#) = happyShift action_14-action_61 (34#) = happyShift action_15-action_61 (41#) = happyShift action_16-action_61 (42#) = happyShift action_17-action_61 (43#) = happyShift action_18-action_61 (49#) = happyShift action_19-action_61 (55#) = happyShift action_20-action_61 (59#) = happyShift action_21-action_61 (60#) = happyShift action_22-action_61 (68#) = happyShift action_23-action_61 (69#) = happyShift action_24-action_61 (73#) = happyShift action_25-action_61 (75#) = happyShift action_26-action_61 (78#) = happyShift action_27-action_61 (79#) = happyShift action_28-action_61 (81#) = happyShift action_29-action_61 (82#) = happyShift action_30-action_61 (83#) = happyShift action_31-action_61 (5#) = happyGoto action_2-action_61 (6#) = happyGoto action_98-action_61 (8#) = happyGoto action_4-action_61 (15#) = happyGoto action_5-action_61 (16#) = happyGoto action_6-action_61 (17#) = happyGoto action_7-action_61 (20#) = happyGoto action_8-action_61 (23#) = happyGoto action_9-action_61 (24#) = happyGoto action_10-action_61 (25#) = happyGoto action_11-action_61 x = happyTcHack x happyFail--action_62 (27#) = happyShift action_12-action_62 (28#) = happyShift action_13-action_62 (29#) = happyShift action_14-action_62 (34#) = happyShift action_15-action_62 (41#) = happyShift action_16-action_62 (42#) = happyShift action_17-action_62 (43#) = happyShift action_18-action_62 (49#) = happyShift action_19-action_62 (55#) = happyShift action_20-action_62 (59#) = happyShift action_21-action_62 (60#) = happyShift action_22-action_62 (68#) = happyShift action_23-action_62 (69#) = happyShift action_24-action_62 (73#) = happyShift action_25-action_62 (75#) = happyShift action_26-action_62 (78#) = happyShift action_27-action_62 (79#) = happyShift action_28-action_62 (81#) = happyShift action_29-action_62 (82#) = happyShift action_30-action_62 (83#) = happyShift action_31-action_62 (5#) = happyGoto action_2-action_62 (6#) = happyGoto action_97-action_62 (8#) = happyGoto action_4-action_62 (15#) = happyGoto action_5-action_62 (16#) = happyGoto action_6-action_62 (17#) = happyGoto action_7-action_62 (20#) = happyGoto action_8-action_62 (23#) = happyGoto action_9-action_62 (24#) = happyGoto action_10-action_62 (25#) = happyGoto action_11-action_62 x = happyTcHack x happyFail--action_63 (27#) = happyShift action_12-action_63 (28#) = happyShift action_13-action_63 (29#) = happyShift action_14-action_63 (34#) = happyShift action_15-action_63 (41#) = happyShift action_16-action_63 (42#) = happyShift action_17-action_63 (43#) = happyShift action_18-action_63 (49#) = happyShift action_19-action_63 (55#) = happyShift action_20-action_63 (59#) = happyShift action_21-action_63 (60#) = happyShift action_22-action_63 (68#) = happyShift action_23-action_63 (69#) = happyShift action_24-action_63 (73#) = happyShift action_25-action_63 (75#) = happyShift action_26-action_63 (78#) = happyShift action_27-action_63 (79#) = happyShift action_28-action_63 (81#) = happyShift action_29-action_63 (82#) = happyShift action_30-action_63 (83#) = happyShift action_31-action_63 (5#) = happyGoto action_2-action_63 (6#) = happyGoto action_96-action_63 (8#) = happyGoto action_4-action_63 (15#) = happyGoto action_5-action_63 (16#) = happyGoto action_6-action_63 (17#) = happyGoto action_7-action_63 (20#) = happyGoto action_8-action_63 (23#) = happyGoto action_9-action_63 (24#) = happyGoto action_10-action_63 (25#) = happyGoto action_11-action_63 x = happyTcHack x happyFail--action_64 (27#) = happyShift action_12-action_64 (28#) = happyShift action_13-action_64 (29#) = happyShift action_14-action_64 (34#) = happyShift action_15-action_64 (41#) = happyShift action_16-action_64 (42#) = happyShift action_17-action_64 (43#) = happyShift action_18-action_64 (49#) = happyShift action_19-action_64 (55#) = happyShift action_20-action_64 (59#) = happyShift action_21-action_64 (60#) = happyShift action_22-action_64 (68#) = happyShift action_23-action_64 (69#) = happyShift action_24-action_64 (73#) = happyShift action_25-action_64 (75#) = happyShift action_26-action_64 (78#) = happyShift action_27-action_64 (79#) = happyShift action_28-action_64 (81#) = happyShift action_29-action_64 (82#) = happyShift action_30-action_64 (83#) = happyShift action_31-action_64 (5#) = happyGoto action_2-action_64 (6#) = happyGoto action_95-action_64 (8#) = happyGoto action_4-action_64 (15#) = happyGoto action_5-action_64 (16#) = happyGoto action_6-action_64 (17#) = happyGoto action_7-action_64 (20#) = happyGoto action_8-action_64 (23#) = happyGoto action_9-action_64 (24#) = happyGoto action_10-action_64 (25#) = happyGoto action_11-action_64 x = happyTcHack x happyFail--action_65 (27#) = happyShift action_12-action_65 (28#) = happyShift action_13-action_65 (29#) = happyShift action_14-action_65 (34#) = happyShift action_15-action_65 (41#) = happyShift action_16-action_65 (42#) = happyShift action_17-action_65 (43#) = happyShift action_18-action_65 (49#) = happyShift action_19-action_65 (55#) = happyShift action_20-action_65 (59#) = happyShift action_21-action_65 (60#) = happyShift action_22-action_65 (68#) = happyShift action_23-action_65 (69#) = happyShift action_24-action_65 (73#) = happyShift action_25-action_65 (75#) = happyShift action_26-action_65 (78#) = happyShift action_27-action_65 (79#) = happyShift action_28-action_65 (81#) = happyShift action_29-action_65 (82#) = happyShift action_30-action_65 (83#) = happyShift action_31-action_65 (5#) = happyGoto action_2-action_65 (6#) = happyGoto action_94-action_65 (8#) = happyGoto action_4-action_65 (15#) = happyGoto action_5-action_65 (16#) = happyGoto action_6-action_65 (17#) = happyGoto action_7-action_65 (20#) = happyGoto action_8-action_65 (23#) = happyGoto action_9-action_65 (24#) = happyGoto action_10-action_65 (25#) = happyGoto action_11-action_65 x = happyTcHack x happyFail--action_66 (27#) = happyShift action_12-action_66 (28#) = happyShift action_13-action_66 (29#) = happyShift action_14-action_66 (34#) = happyShift action_15-action_66 (41#) = happyShift action_16-action_66 (42#) = happyShift action_17-action_66 (43#) = happyShift action_18-action_66 (49#) = happyShift action_19-action_66 (55#) = happyShift action_20-action_66 (59#) = happyShift action_21-action_66 (60#) = happyShift action_22-action_66 (68#) = happyShift action_23-action_66 (69#) = happyShift action_24-action_66 (73#) = happyShift action_25-action_66 (75#) = happyShift action_26-action_66 (78#) = happyShift action_27-action_66 (79#) = happyShift action_28-action_66 (81#) = happyShift action_29-action_66 (82#) = happyShift action_30-action_66 (83#) = happyShift action_31-action_66 (5#) = happyGoto action_2-action_66 (6#) = happyGoto action_93-action_66 (8#) = happyGoto action_4-action_66 (15#) = happyGoto action_5-action_66 (16#) = happyGoto action_6-action_66 (17#) = happyGoto action_7-action_66 (20#) = happyGoto action_8-action_66 (23#) = happyGoto action_9-action_66 (24#) = happyGoto action_10-action_66 (25#) = happyGoto action_11-action_66 x = happyTcHack x happyFail--action_67 (27#) = happyShift action_12-action_67 (28#) = happyShift action_13-action_67 (29#) = happyShift action_14-action_67 (34#) = happyShift action_15-action_67 (41#) = happyShift action_16-action_67 (42#) = happyShift action_17-action_67 (43#) = happyShift action_18-action_67 (49#) = happyShift action_19-action_67 (55#) = happyShift action_20-action_67 (59#) = happyShift action_21-action_67 (60#) = happyShift action_22-action_67 (68#) = happyShift action_23-action_67 (69#) = happyShift action_24-action_67 (73#) = happyShift action_25-action_67 (75#) = happyShift action_26-action_67 (78#) = happyShift action_27-action_67 (79#) = happyShift action_28-action_67 (81#) = happyShift action_29-action_67 (82#) = happyShift action_30-action_67 (83#) = happyShift action_31-action_67 (5#) = happyGoto action_2-action_67 (6#) = happyGoto action_92-action_67 (8#) = happyGoto action_4-action_67 (15#) = happyGoto action_5-action_67 (16#) = happyGoto action_6-action_67 (17#) = happyGoto action_7-action_67 (20#) = happyGoto action_8-action_67 (23#) = happyGoto action_9-action_67 (24#) = happyGoto action_10-action_67 (25#) = happyGoto action_11-action_67 x = happyTcHack x happyFail--action_68 (27#) = happyShift action_12-action_68 (28#) = happyShift action_13-action_68 (29#) = happyShift action_14-action_68 (34#) = happyShift action_15-action_68 (41#) = happyShift action_16-action_68 (42#) = happyShift action_17-action_68 (43#) = happyShift action_18-action_68 (49#) = happyShift action_19-action_68 (55#) = happyShift action_20-action_68 (59#) = happyShift action_21-action_68 (60#) = happyShift action_22-action_68 (68#) = happyShift action_23-action_68 (69#) = happyShift action_24-action_68 (73#) = happyShift action_25-action_68 (75#) = happyShift action_26-action_68 (78#) = happyShift action_27-action_68 (79#) = happyShift action_28-action_68 (81#) = happyShift action_29-action_68 (82#) = happyShift action_30-action_68 (83#) = happyShift action_31-action_68 (5#) = happyGoto action_2-action_68 (6#) = happyGoto action_91-action_68 (8#) = happyGoto action_4-action_68 (15#) = happyGoto action_5-action_68 (16#) = happyGoto action_6-action_68 (17#) = happyGoto action_7-action_68 (20#) = happyGoto action_8-action_68 (23#) = happyGoto action_9-action_68 (24#) = happyGoto action_10-action_68 (25#) = happyGoto action_11-action_68 x = happyTcHack x happyFail--action_69 (27#) = happyShift action_12-action_69 (28#) = happyShift action_13-action_69 (29#) = happyShift action_14-action_69 (34#) = happyShift action_15-action_69 (41#) = happyShift action_16-action_69 (42#) = happyShift action_17-action_69 (43#) = happyShift action_18-action_69 (49#) = happyShift action_19-action_69 (55#) = happyShift action_20-action_69 (59#) = happyShift action_21-action_69 (60#) = happyShift action_22-action_69 (68#) = happyShift action_23-action_69 (69#) = happyShift action_24-action_69 (73#) = happyShift action_25-action_69 (75#) = happyShift action_26-action_69 (78#) = happyShift action_27-action_69 (79#) = happyShift action_28-action_69 (81#) = happyShift action_29-action_69 (82#) = happyShift action_30-action_69 (83#) = happyShift action_31-action_69 (5#) = happyGoto action_2-action_69 (6#) = happyGoto action_90-action_69 (8#) = happyGoto action_4-action_69 (15#) = happyGoto action_5-action_69 (16#) = happyGoto action_6-action_69 (17#) = happyGoto action_7-action_69 (20#) = happyGoto action_8-action_69 (23#) = happyGoto action_9-action_69 (24#) = happyGoto action_10-action_69 (25#) = happyGoto action_11-action_69 x = happyTcHack x happyFail--action_70 (27#) = happyShift action_12-action_70 (28#) = happyShift action_13-action_70 (29#) = happyShift action_14-action_70 (34#) = happyShift action_15-action_70 (41#) = happyShift action_16-action_70 (42#) = happyShift action_17-action_70 (43#) = happyShift action_18-action_70 (49#) = happyShift action_19-action_70 (55#) = happyShift action_20-action_70 (59#) = happyShift action_21-action_70 (60#) = happyShift action_22-action_70 (68#) = happyShift action_23-action_70 (69#) = happyShift action_24-action_70 (73#) = happyShift action_25-action_70 (75#) = happyShift action_26-action_70 (78#) = happyShift action_27-action_70 (79#) = happyShift action_28-action_70 (81#) = happyShift action_29-action_70 (82#) = happyShift action_30-action_70 (83#) = happyShift action_31-action_70 (5#) = happyGoto action_2-action_70 (6#) = happyGoto action_89-action_70 (8#) = happyGoto action_4-action_70 (15#) = happyGoto action_5-action_70 (16#) = happyGoto action_6-action_70 (17#) = happyGoto action_7-action_70 (20#) = happyGoto action_8-action_70 (23#) = happyGoto action_9-action_70 (24#) = happyGoto action_10-action_70 (25#) = happyGoto action_11-action_70 x = happyTcHack x happyFail--action_71 (27#) = happyShift action_12-action_71 (28#) = happyShift action_13-action_71 (29#) = happyShift action_14-action_71 (34#) = happyShift action_15-action_71 (41#) = happyShift action_16-action_71 (42#) = happyShift action_17-action_71 (43#) = happyShift action_18-action_71 (49#) = happyShift action_19-action_71 (55#) = happyShift action_20-action_71 (59#) = happyShift action_21-action_71 (60#) = happyShift action_22-action_71 (68#) = happyShift action_23-action_71 (69#) = happyShift action_24-action_71 (73#) = happyShift action_25-action_71 (75#) = happyShift action_26-action_71 (78#) = happyShift action_27-action_71 (79#) = happyShift action_28-action_71 (81#) = happyShift action_29-action_71 (82#) = happyShift action_30-action_71 (83#) = happyShift action_31-action_71 (5#) = happyGoto action_2-action_71 (6#) = happyGoto action_88-action_71 (8#) = happyGoto action_4-action_71 (15#) = happyGoto action_5-action_71 (16#) = happyGoto action_6-action_71 (17#) = happyGoto action_7-action_71 (20#) = happyGoto action_8-action_71 (23#) = happyGoto action_9-action_71 (24#) = happyGoto action_10-action_71 (25#) = happyGoto action_11-action_71 x = happyTcHack x happyFail--action_72 (27#) = happyShift action_12-action_72 (28#) = happyShift action_13-action_72 (29#) = happyShift action_14-action_72 (34#) = happyShift action_15-action_72 (41#) = happyShift action_16-action_72 (42#) = happyShift action_17-action_72 (43#) = happyShift action_18-action_72 (49#) = happyShift action_19-action_72 (55#) = happyShift action_20-action_72 (59#) = happyShift action_21-action_72 (60#) = happyShift action_22-action_72 (68#) = happyShift action_23-action_72 (69#) = happyShift action_24-action_72 (73#) = happyShift action_25-action_72 (75#) = happyShift action_26-action_72 (78#) = happyShift action_27-action_72 (79#) = happyShift action_28-action_72 (81#) = happyShift action_29-action_72 (82#) = happyShift action_30-action_72 (83#) = happyShift action_31-action_72 (5#) = happyGoto action_2-action_72 (6#) = happyGoto action_87-action_72 (8#) = happyGoto action_4-action_72 (15#) = happyGoto action_5-action_72 (16#) = happyGoto action_6-action_72 (17#) = happyGoto action_7-action_72 (20#) = happyGoto action_8-action_72 (23#) = happyGoto action_9-action_72 (24#) = happyGoto action_10-action_72 (25#) = happyGoto action_11-action_72 x = happyTcHack x happyFail--action_73 (27#) = happyShift action_12-action_73 (28#) = happyShift action_13-action_73 (29#) = happyShift action_14-action_73 (34#) = happyShift action_15-action_73 (41#) = happyShift action_16-action_73 (42#) = happyShift action_17-action_73 (43#) = happyShift action_18-action_73 (49#) = happyShift action_19-action_73 (55#) = happyShift action_20-action_73 (59#) = happyShift action_21-action_73 (60#) = happyShift action_22-action_73 (68#) = happyShift action_23-action_73 (69#) = happyShift action_24-action_73 (73#) = happyShift action_25-action_73 (75#) = happyShift action_26-action_73 (78#) = happyShift action_27-action_73 (79#) = happyShift action_28-action_73 (81#) = happyShift action_29-action_73 (82#) = happyShift action_30-action_73 (83#) = happyShift action_31-action_73 (5#) = happyGoto action_2-action_73 (6#) = happyGoto action_86-action_73 (8#) = happyGoto action_4-action_73 (15#) = happyGoto action_5-action_73 (16#) = happyGoto action_6-action_73 (17#) = happyGoto action_7-action_73 (20#) = happyGoto action_8-action_73 (23#) = happyGoto action_9-action_73 (24#) = happyGoto action_10-action_73 (25#) = happyGoto action_11-action_73 x = happyTcHack x happyFail--action_74 (27#) = happyShift action_12-action_74 (28#) = happyShift action_13-action_74 (29#) = happyShift action_14-action_74 (34#) = happyShift action_15-action_74 (41#) = happyShift action_16-action_74 (42#) = happyShift action_17-action_74 (43#) = happyShift action_18-action_74 (49#) = happyShift action_19-action_74 (55#) = happyShift action_20-action_74 (59#) = happyShift action_21-action_74 (60#) = happyShift action_22-action_74 (68#) = happyShift action_23-action_74 (69#) = happyShift action_24-action_74 (73#) = happyShift action_25-action_74 (75#) = happyShift action_26-action_74 (78#) = happyShift action_27-action_74 (79#) = happyShift action_28-action_74 (81#) = happyShift action_29-action_74 (82#) = happyShift action_30-action_74 (83#) = happyShift action_31-action_74 (5#) = happyGoto action_2-action_74 (6#) = happyGoto action_85-action_74 (8#) = happyGoto action_4-action_74 (15#) = happyGoto action_5-action_74 (16#) = happyGoto action_6-action_74 (17#) = happyGoto action_7-action_74 (20#) = happyGoto action_8-action_74 (23#) = happyGoto action_9-action_74 (24#) = happyGoto action_10-action_74 (25#) = happyGoto action_11-action_74 x = happyTcHack x happyFail--action_75 (27#) = happyShift action_12-action_75 (28#) = happyShift action_13-action_75 (29#) = happyShift action_14-action_75 (34#) = happyShift action_15-action_75 (41#) = happyShift action_16-action_75 (42#) = happyShift action_17-action_75 (43#) = happyShift action_18-action_75 (49#) = happyShift action_19-action_75 (55#) = happyShift action_20-action_75 (59#) = happyShift action_21-action_75 (60#) = happyShift action_22-action_75 (68#) = happyShift action_23-action_75 (69#) = happyShift action_24-action_75 (73#) = happyShift action_25-action_75 (75#) = happyShift action_26-action_75 (78#) = happyShift action_27-action_75 (79#) = happyShift action_28-action_75 (81#) = happyShift action_29-action_75 (82#) = happyShift action_30-action_75 (83#) = happyShift action_31-action_75 (5#) = happyGoto action_2-action_75 (6#) = happyGoto action_84-action_75 (8#) = happyGoto action_4-action_75 (15#) = happyGoto action_5-action_75 (16#) = happyGoto action_6-action_75 (17#) = happyGoto action_7-action_75 (20#) = happyGoto action_8-action_75 (23#) = happyGoto action_9-action_75 (24#) = happyGoto action_10-action_75 (25#) = happyGoto action_11-action_75 x = happyTcHack x happyFail--action_76 (27#) = happyShift action_12-action_76 (28#) = happyShift action_13-action_76 (29#) = happyShift action_14-action_76 (34#) = happyShift action_15-action_76 (41#) = happyShift action_16-action_76 (42#) = happyShift action_17-action_76 (43#) = happyShift action_18-action_76 (49#) = happyShift action_19-action_76 (55#) = happyShift action_20-action_76 (59#) = happyShift action_21-action_76 (60#) = happyShift action_22-action_76 (68#) = happyShift action_23-action_76 (69#) = happyShift action_24-action_76 (73#) = happyShift action_25-action_76 (75#) = happyShift action_26-action_76 (78#) = happyShift action_27-action_76 (79#) = happyShift action_28-action_76 (81#) = happyShift action_29-action_76 (82#) = happyShift action_30-action_76 (83#) = happyShift action_31-action_76 (5#) = happyGoto action_2-action_76 (6#) = happyGoto action_83-action_76 (8#) = happyGoto action_4-action_76 (15#) = happyGoto action_5-action_76 (16#) = happyGoto action_6-action_76 (17#) = happyGoto action_7-action_76 (20#) = happyGoto action_8-action_76 (23#) = happyGoto action_9-action_76 (24#) = happyGoto action_10-action_76 (25#) = happyGoto action_11-action_76 x = happyTcHack x happyFail--action_77 (27#) = happyShift action_12-action_77 (28#) = happyShift action_13-action_77 (29#) = happyShift action_14-action_77 (34#) = happyShift action_15-action_77 (41#) = happyShift action_16-action_77 (42#) = happyShift action_17-action_77 (43#) = happyShift action_18-action_77 (49#) = happyShift action_19-action_77 (55#) = happyShift action_20-action_77 (59#) = happyShift action_21-action_77 (60#) = happyShift action_22-action_77 (68#) = happyShift action_23-action_77 (69#) = happyShift action_24-action_77 (73#) = happyShift action_25-action_77 (75#) = happyShift action_26-action_77 (78#) = happyShift action_27-action_77 (79#) = happyShift action_28-action_77 (81#) = happyShift action_29-action_77 (82#) = happyShift action_30-action_77 (83#) = happyShift action_31-action_77 (5#) = happyGoto action_2-action_77 (6#) = happyGoto action_82-action_77 (8#) = happyGoto action_4-action_77 (15#) = happyGoto action_5-action_77 (16#) = happyGoto action_6-action_77 (17#) = happyGoto action_7-action_77 (20#) = happyGoto action_8-action_77 (23#) = happyGoto action_9-action_77 (24#) = happyGoto action_10-action_77 (25#) = happyGoto action_11-action_77 x = happyTcHack x happyFail--action_78 (27#) = happyShift action_12-action_78 (28#) = happyShift action_13-action_78 (29#) = happyShift action_14-action_78 (34#) = happyShift action_15-action_78 (41#) = happyShift action_16-action_78 (42#) = happyShift action_17-action_78 (43#) = happyShift action_18-action_78 (49#) = happyShift action_19-action_78 (55#) = happyShift action_20-action_78 (59#) = happyShift action_21-action_78 (60#) = happyShift action_22-action_78 (68#) = happyShift action_23-action_78 (69#) = happyShift action_24-action_78 (73#) = happyShift action_25-action_78 (75#) = happyShift action_26-action_78 (78#) = happyShift action_27-action_78 (79#) = happyShift action_28-action_78 (81#) = happyShift action_29-action_78 (82#) = happyShift action_30-action_78 (83#) = happyShift action_31-action_78 (5#) = happyGoto action_2-action_78 (6#) = happyGoto action_81-action_78 (8#) = happyGoto action_4-action_78 (15#) = happyGoto action_5-action_78 (16#) = happyGoto action_6-action_78 (17#) = happyGoto action_7-action_78 (20#) = happyGoto action_8-action_78 (23#) = happyGoto action_9-action_78 (24#) = happyGoto action_10-action_78 (25#) = happyGoto action_11-action_78 x = happyTcHack x happyFail--action_79 (27#) = happyShift action_12-action_79 (28#) = happyShift action_13-action_79 (29#) = happyShift action_14-action_79 (34#) = happyShift action_15-action_79 (41#) = happyShift action_16-action_79 (42#) = happyShift action_17-action_79 (43#) = happyShift action_18-action_79 (49#) = happyShift action_19-action_79 (55#) = happyShift action_20-action_79 (59#) = happyShift action_21-action_79 (60#) = happyShift action_22-action_79 (68#) = happyShift action_23-action_79 (69#) = happyShift action_24-action_79 (73#) = happyShift action_25-action_79 (75#) = happyShift action_26-action_79 (78#) = happyShift action_27-action_79 (79#) = happyShift action_28-action_79 (81#) = happyShift action_29-action_79 (82#) = happyShift action_30-action_79 (83#) = happyShift action_31-action_79 (5#) = happyGoto action_2-action_79 (6#) = happyGoto action_80-action_79 (8#) = happyGoto action_4-action_79 (15#) = happyGoto action_5-action_79 (16#) = happyGoto action_6-action_79 (17#) = happyGoto action_7-action_79 (20#) = happyGoto action_8-action_79 (23#) = happyGoto action_9-action_79 (24#) = happyGoto action_10-action_79 (25#) = happyGoto action_11-action_79 x = happyTcHack x happyFail--action_80 (40#) = happyShift action_61-action_80 (41#) = happyShift action_62-action_80 (42#) = happyShift action_63-action_80 (43#) = happyShift action_64-action_80 (44#) = happyShift action_65-action_80 (45#) = happyShift action_66-action_80 (46#) = happyShift action_67-action_80 (47#) = happyShift action_68-action_80 (48#) = happyShift action_69-action_80 (49#) = happyShift action_70-action_80 (50#) = happyShift action_71-action_80 (51#) = happyShift action_72-action_80 (52#) = happyShift action_73-action_80 (53#) = happyShift action_74-action_80 (54#) = happyShift action_75-action_80 (55#) = happyShift action_76-action_80 x = happyTcHack x happyReduce_28--action_81 (40#) = happyShift action_61-action_81 (41#) = happyShift action_62-action_81 (42#) = happyShift action_63-action_81 (43#) = happyShift action_64-action_81 (44#) = happyShift action_65-action_81 (45#) = happyShift action_66-action_81 (46#) = happyShift action_67-action_81 (47#) = happyShift action_68-action_81 (48#) = happyShift action_69-action_81 (49#) = happyShift action_70-action_81 (50#) = happyShift action_71-action_81 (51#) = happyShift action_72-action_81 (52#) = happyShift action_73-action_81 (53#) = happyShift action_74-action_81 (54#) = happyShift action_75-action_81 (55#) = happyShift action_76-action_81 x = happyTcHack x happyReduce_27--action_82 (40#) = happyShift action_61-action_82 (41#) = happyShift action_62-action_82 (42#) = happyShift action_63-action_82 (43#) = happyShift action_64-action_82 (44#) = happyShift action_65-action_82 (45#) = happyShift action_66-action_82 (46#) = happyShift action_67-action_82 (47#) = happyShift action_68-action_82 (48#) = happyShift action_69-action_82 (49#) = happyShift action_70-action_82 (50#) = happyShift action_71-action_82 (51#) = happyShift action_72-action_82 (52#) = happyShift action_73-action_82 (53#) = happyShift action_74-action_82 (54#) = happyShift action_75-action_82 (55#) = happyShift action_76-action_82 x = happyTcHack x happyReduce_26--action_83 (40#) = happyShift action_61-action_83 (41#) = happyShift action_62-action_83 (42#) = happyShift action_63-action_83 (43#) = happyShift action_64-action_83 (44#) = happyShift action_65-action_83 (45#) = happyShift action_66-action_83 (46#) = happyShift action_67-action_83 (47#) = happyShift action_68-action_83 (48#) = happyShift action_69-action_83 (49#) = happyShift action_70-action_83 (50#) = happyShift action_71-action_83 (51#) = happyShift action_72-action_83 (52#) = happyShift action_73-action_83 (55#) = happyFail-action_83 x = happyTcHack x happyReduce_25--action_84 (40#) = happyShift action_61-action_84 (41#) = happyShift action_62-action_84 (42#) = happyShift action_63-action_84 (43#) = happyShift action_64-action_84 (44#) = happyShift action_65-action_84 (45#) = happyShift action_66-action_84 (46#) = happyShift action_67-action_84 (47#) = happyShift action_68-action_84 (48#) = happyShift action_69-action_84 (49#) = happyShift action_70-action_84 (50#) = happyShift action_71-action_84 (51#) = happyShift action_72-action_84 (52#) = happyShift action_73-action_84 (53#) = happyShift action_74-action_84 (54#) = happyShift action_75-action_84 (55#) = happyShift action_76-action_84 x = happyTcHack x happyReduce_24--action_85 (40#) = happyShift action_61-action_85 (41#) = happyShift action_62-action_85 (42#) = happyShift action_63-action_85 (43#) = happyShift action_64-action_85 (44#) = happyShift action_65-action_85 (45#) = happyShift action_66-action_85 (46#) = happyShift action_67-action_85 (47#) = happyShift action_68-action_85 (48#) = happyShift action_69-action_85 (49#) = happyShift action_70-action_85 (50#) = happyShift action_71-action_85 (51#) = happyShift action_72-action_85 (52#) = happyShift action_73-action_85 (53#) = happyShift action_74-action_85 (55#) = happyShift action_76-action_85 x = happyTcHack x happyReduce_23--action_86 (41#) = happyShift action_62-action_86 (42#) = happyShift action_63-action_86 (43#) = happyShift action_64-action_86 (44#) = happyShift action_65-action_86 (45#) = happyShift action_66-action_86 (46#) = happyShift action_67-action_86 x = happyTcHack x happyReduce_22--action_87 (41#) = happyShift action_62-action_87 (42#) = happyShift action_63-action_87 (43#) = happyShift action_64-action_87 (44#) = happyShift action_65-action_87 (45#) = happyShift action_66-action_87 (46#) = happyShift action_67-action_87 x = happyTcHack x happyReduce_21--action_88 (41#) = happyShift action_62-action_88 (42#) = happyShift action_63-action_88 (43#) = happyShift action_64-action_88 (44#) = happyShift action_65-action_88 (45#) = happyShift action_66-action_88 (46#) = happyShift action_67-action_88 x = happyTcHack x happyReduce_20--action_89 (41#) = happyShift action_62-action_89 (42#) = happyShift action_63-action_89 (43#) = happyShift action_64-action_89 (44#) = happyShift action_65-action_89 (45#) = happyShift action_66-action_89 (46#) = happyShift action_67-action_89 x = happyTcHack x happyReduce_19--action_90 (41#) = happyShift action_62-action_90 (42#) = happyShift action_63-action_90 (43#) = happyShift action_64-action_90 (44#) = happyShift action_65-action_90 (45#) = happyShift action_66-action_90 (46#) = happyShift action_67-action_90 x = happyTcHack x happyReduce_18--action_91 (41#) = happyShift action_62-action_91 (42#) = happyShift action_63-action_91 (43#) = happyShift action_64-action_91 (44#) = happyShift action_65-action_91 (45#) = happyShift action_66-action_91 (46#) = happyShift action_67-action_91 x = happyTcHack x happyReduce_17--action_92 x = happyTcHack x happyReduce_16--action_93 x = happyTcHack x happyReduce_15--action_94 x = happyTcHack x happyReduce_14--action_95 x = happyTcHack x happyReduce_13--action_96 (43#) = happyShift action_64-action_96 (44#) = happyShift action_65-action_96 (45#) = happyShift action_66-action_96 (46#) = happyShift action_67-action_96 x = happyTcHack x happyReduce_12--action_97 (43#) = happyShift action_64-action_97 (44#) = happyShift action_65-action_97 (45#) = happyShift action_66-action_97 (46#) = happyShift action_67-action_97 x = happyTcHack x happyReduce_11--action_98 (41#) = happyShift action_62-action_98 (42#) = happyShift action_63-action_98 (43#) = happyShift action_64-action_98 (44#) = happyShift action_65-action_98 (45#) = happyShift action_66-action_98 (46#) = happyShift action_67-action_98 (47#) = happyShift action_68-action_98 (48#) = happyShift action_69-action_98 (49#) = happyShift action_70-action_98 (50#) = happyShift action_71-action_98 (51#) = happyShift action_72-action_98 (52#) = happyShift action_73-action_98 x = happyTcHack x happyReduce_10--action_99 (40#) = happyShift action_61-action_99 (41#) = happyShift action_62-action_99 (42#) = happyShift action_63-action_99 (43#) = happyShift action_64-action_99 (44#) = happyShift action_65-action_99 (45#) = happyShift action_66-action_99 (46#) = happyShift action_67-action_99 (47#) = happyShift action_68-action_99 (48#) = happyShift action_69-action_99 (49#) = happyShift action_70-action_99 (50#) = happyShift action_71-action_99 (51#) = happyShift action_72-action_99 (52#) = happyShift action_73-action_99 (53#) = happyShift action_74-action_99 (54#) = happyShift action_75-action_99 (55#) = happyShift action_76-action_99 (56#) = happyShift action_77-action_99 (57#) = happyShift action_78-action_99 (58#) = happyShift action_79-action_99 x = happyTcHack x happyReduce_47--action_100 (62#) = happyShift action_125-action_100 x = happyTcHack x happyReduce_40--action_101 (62#) = happyShift action_116-action_101 x = happyTcHack x happyReduce_39--action_102 (26#) = happyShift action_158-action_102 x = happyTcHack x happyFail--action_103 (27#) = happyShift action_12-action_103 (28#) = happyShift action_13-action_103 (29#) = happyShift action_14-action_103 (34#) = happyShift action_15-action_103 (41#) = happyShift action_16-action_103 (42#) = happyShift action_17-action_103 (43#) = happyShift action_18-action_103 (49#) = happyShift action_19-action_103 (55#) = happyShift action_20-action_103 (59#) = happyShift action_21-action_103 (60#) = happyShift action_22-action_103 (68#) = happyShift action_23-action_103 (69#) = happyShift action_24-action_103 (73#) = happyShift action_25-action_103 (75#) = happyShift action_26-action_103 (78#) = happyShift action_27-action_103 (79#) = happyShift action_28-action_103 (81#) = happyShift action_29-action_103 (82#) = happyShift action_30-action_103 (83#) = happyShift action_31-action_103 (5#) = happyGoto action_2-action_103 (6#) = happyGoto action_156-action_103 (8#) = happyGoto action_4-action_103 (13#) = happyGoto action_157-action_103 (15#) = happyGoto action_5-action_103 (16#) = happyGoto action_6-action_103 (17#) = happyGoto action_7-action_103 (20#) = happyGoto action_8-action_103 (23#) = happyGoto action_9-action_103 (24#) = happyGoto action_10-action_103 (25#) = happyGoto action_11-action_103 x = happyTcHack x happyFail--action_104 x = happyTcHack x happyReduce_66--action_105 (36#) = happyShift action_152-action_105 (49#) = happyShift action_19-action_105 (70#) = happyShift action_153-action_105 (80#) = happyShift action_154-action_105 (83#) = happyShift action_155-action_105 (16#) = happyGoto action_151-action_105 (17#) = happyGoto action_7-action_105 x = happyTcHack x happyFail--action_106 (27#) = happyShift action_12-action_106 (28#) = happyShift action_13-action_106 (29#) = happyShift action_14-action_106 (34#) = happyShift action_15-action_106 (41#) = happyShift action_16-action_106 (42#) = happyShift action_17-action_106 (43#) = happyShift action_18-action_106 (49#) = happyShift action_19-action_106 (55#) = happyShift action_20-action_106 (59#) = happyShift action_21-action_106 (60#) = happyShift action_22-action_106 (68#) = happyShift action_23-action_106 (69#) = happyShift action_24-action_106 (73#) = happyShift action_25-action_106 (75#) = happyShift action_26-action_106 (78#) = happyShift action_27-action_106 (79#) = happyShift action_28-action_106 (81#) = happyShift action_29-action_106 (82#) = happyShift action_30-action_106 (83#) = happyShift action_31-action_106 (5#) = happyGoto action_2-action_106 (6#) = happyGoto action_45-action_106 (7#) = happyGoto action_150-action_106 (8#) = happyGoto action_4-action_106 (15#) = happyGoto action_5-action_106 (16#) = happyGoto action_6-action_106 (17#) = happyGoto action_7-action_106 (20#) = happyGoto action_8-action_106 (23#) = happyGoto action_9-action_106 (24#) = happyGoto action_10-action_106 (25#) = happyGoto action_11-action_106 x = happyTcHack x happyFail--action_107 (75#) = happyShift action_149-action_107 x = happyTcHack x happyFail--action_108 x = happyTcHack x happyReduce_65--action_109 x = happyTcHack x happyReduce_64--action_110 (32#) = happyShift action_53-action_110 x = happyTcHack x happyReduce_81--action_111 (34#) = happyShift action_15-action_111 (43#) = happyShift action_18-action_111 (75#) = happyShift action_26-action_111 (78#) = happyShift action_27-action_111 (79#) = happyShift action_28-action_111 (5#) = happyGoto action_2-action_111 (23#) = happyGoto action_148-action_111 (24#) = happyGoto action_10-action_111 (25#) = happyGoto action_11-action_111 x = happyTcHack x happyFail--action_112 (34#) = happyShift action_15-action_112 (43#) = happyShift action_18-action_112 (73#) = happyShift action_147-action_112 (75#) = happyShift action_26-action_112 (78#) = happyShift action_27-action_112 (79#) = happyShift action_28-action_112 (5#) = happyGoto action_2-action_112 (23#) = happyGoto action_146-action_112 (24#) = happyGoto action_10-action_112 (25#) = happyGoto action_11-action_112 x = happyTcHack x happyFail--action_113 x = happyTcHack x happyReduce_85--action_114 (33#) = happyShift action_145-action_114 (40#) = happyShift action_61-action_114 (41#) = happyShift action_62-action_114 (42#) = happyShift action_63-action_114 (43#) = happyShift action_64-action_114 (44#) = happyShift action_65-action_114 (45#) = happyShift action_66-action_114 (46#) = happyShift action_67-action_114 (47#) = happyShift action_68-action_114 (48#) = happyShift action_69-action_114 (49#) = happyShift action_70-action_114 (50#) = happyShift action_71-action_114 (51#) = happyShift action_72-action_114 (52#) = happyShift action_73-action_114 (53#) = happyShift action_74-action_114 (54#) = happyShift action_75-action_114 (55#) = happyShift action_76-action_114 (56#) = happyShift action_77-action_114 (57#) = happyShift action_78-action_114 (58#) = happyShift action_79-action_114 x = happyTcHack x happyFail--action_115 x = happyTcHack x happyReduce_80--action_116 (79#) = happyShift action_28-action_116 (5#) = happyGoto action_144-action_116 x = happyTcHack x happyFail--action_117 (27#) = happyShift action_12-action_117 (28#) = happyShift action_13-action_117 (29#) = happyShift action_14-action_117 (34#) = happyShift action_15-action_117 (41#) = happyShift action_16-action_117 (42#) = happyShift action_17-action_117 (43#) = happyShift action_18-action_117 (49#) = happyShift action_19-action_117 (55#) = happyShift action_20-action_117 (59#) = happyShift action_21-action_117 (60#) = happyShift action_22-action_117 (68#) = happyShift action_23-action_117 (69#) = happyShift action_24-action_117 (73#) = happyShift action_25-action_117 (75#) = happyShift action_26-action_117 (78#) = happyShift action_27-action_117 (79#) = happyShift action_28-action_117 (81#) = happyShift action_29-action_117 (82#) = happyShift action_30-action_117 (83#) = happyShift action_31-action_117 (5#) = happyGoto action_2-action_117 (6#) = happyGoto action_143-action_117 (8#) = happyGoto action_4-action_117 (15#) = happyGoto action_5-action_117 (16#) = happyGoto action_6-action_117 (17#) = happyGoto action_7-action_117 (20#) = happyGoto action_8-action_117 (23#) = happyGoto action_9-action_117 (24#) = happyGoto action_10-action_117 (25#) = happyGoto action_11-action_117 x = happyTcHack x happyFail--action_118 (27#) = happyShift action_12-action_118 (28#) = happyShift action_13-action_118 (29#) = happyShift action_14-action_118 (34#) = happyShift action_15-action_118 (41#) = happyShift action_16-action_118 (42#) = happyShift action_17-action_118 (43#) = happyShift action_18-action_118 (49#) = happyShift action_19-action_118 (55#) = happyShift action_20-action_118 (59#) = happyShift action_21-action_118 (60#) = happyShift action_22-action_118 (68#) = happyShift action_23-action_118 (69#) = happyShift action_24-action_118 (73#) = happyShift action_25-action_118 (75#) = happyShift action_26-action_118 (78#) = happyShift action_27-action_118 (79#) = happyShift action_28-action_118 (81#) = happyShift action_29-action_118 (82#) = happyShift action_30-action_118 (83#) = happyShift action_31-action_118 (5#) = happyGoto action_2-action_118 (6#) = happyGoto action_142-action_118 (8#) = happyGoto action_4-action_118 (15#) = happyGoto action_5-action_118 (16#) = happyGoto action_6-action_118 (17#) = happyGoto action_7-action_118 (20#) = happyGoto action_8-action_118 (23#) = happyGoto action_9-action_118 (24#) = happyGoto action_10-action_118 (25#) = happyGoto action_11-action_118 x = happyTcHack x happyFail--action_119 (27#) = happyShift action_12-action_119 (28#) = happyShift action_13-action_119 (29#) = happyShift action_14-action_119 (34#) = happyShift action_15-action_119 (41#) = happyShift action_16-action_119 (42#) = happyShift action_17-action_119 (43#) = happyShift action_18-action_119 (49#) = happyShift action_19-action_119 (55#) = happyShift action_20-action_119 (59#) = happyShift action_21-action_119 (60#) = happyShift action_22-action_119 (68#) = happyShift action_23-action_119 (69#) = happyShift action_24-action_119 (73#) = happyShift action_25-action_119 (75#) = happyShift action_26-action_119 (78#) = happyShift action_27-action_119 (79#) = happyShift action_28-action_119 (81#) = happyShift action_29-action_119 (82#) = happyShift action_30-action_119 (83#) = happyShift action_31-action_119 (5#) = happyGoto action_2-action_119 (6#) = happyGoto action_141-action_119 (8#) = happyGoto action_4-action_119 (15#) = happyGoto action_5-action_119 (16#) = happyGoto action_6-action_119 (17#) = happyGoto action_7-action_119 (20#) = happyGoto action_8-action_119 (23#) = happyGoto action_9-action_119 (24#) = happyGoto action_10-action_119 (25#) = happyGoto action_11-action_119 x = happyTcHack x happyFail--action_120 x = happyTcHack x happyReduce_93--action_121 (27#) = happyShift action_12-action_121 (28#) = happyShift action_13-action_121 (29#) = happyShift action_14-action_121 (34#) = happyShift action_15-action_121 (41#) = happyShift action_16-action_121 (42#) = happyShift action_17-action_121 (43#) = happyShift action_18-action_121 (49#) = happyShift action_19-action_121 (55#) = happyShift action_20-action_121 (59#) = happyShift action_21-action_121 (60#) = happyShift action_22-action_121 (68#) = happyShift action_23-action_121 (69#) = happyShift action_24-action_121 (73#) = happyShift action_25-action_121 (75#) = happyShift action_26-action_121 (78#) = happyShift action_27-action_121 (79#) = happyShift action_28-action_121 (81#) = happyShift action_29-action_121 (82#) = happyShift action_30-action_121 (83#) = happyShift action_31-action_121 (5#) = happyGoto action_2-action_121 (6#) = happyGoto action_140-action_121 (8#) = happyGoto action_4-action_121 (15#) = happyGoto action_5-action_121 (16#) = happyGoto action_6-action_121 (17#) = happyGoto action_7-action_121 (20#) = happyGoto action_8-action_121 (23#) = happyGoto action_9-action_121 (24#) = happyGoto action_10-action_121 (25#) = happyGoto action_11-action_121 x = happyTcHack x happyFail--action_122 (75#) = happyShift action_139-action_122 x = happyTcHack x happyReduce_62--action_123 (47#) = happyShift action_138-action_123 x = happyTcHack x happyFail--action_124 (27#) = happyShift action_12-action_124 (28#) = happyShift action_13-action_124 (29#) = happyShift action_14-action_124 (34#) = happyShift action_15-action_124 (41#) = happyShift action_16-action_124 (42#) = happyShift action_17-action_124 (43#) = happyShift action_18-action_124 (49#) = happyShift action_19-action_124 (55#) = happyShift action_20-action_124 (59#) = happyShift action_21-action_124 (60#) = happyShift action_22-action_124 (68#) = happyShift action_23-action_124 (69#) = happyShift action_24-action_124 (73#) = happyShift action_25-action_124 (75#) = happyShift action_26-action_124 (78#) = happyShift action_27-action_124 (79#) = happyShift action_28-action_124 (81#) = happyShift action_29-action_124 (82#) = happyShift action_30-action_124 (83#) = happyShift action_31-action_124 (5#) = happyGoto action_2-action_124 (6#) = happyGoto action_137-action_124 (8#) = happyGoto action_4-action_124 (15#) = happyGoto action_5-action_124 (16#) = happyGoto action_6-action_124 (17#) = happyGoto action_7-action_124 (20#) = happyGoto action_8-action_124 (23#) = happyGoto action_9-action_124 (24#) = happyGoto action_10-action_124 (25#) = happyGoto action_11-action_124 x = happyTcHack x happyFail--action_125 (79#) = happyShift action_28-action_125 (5#) = happyGoto action_136-action_125 x = happyTcHack x happyFail--action_126 (27#) = happyShift action_12-action_126 (28#) = happyShift action_13-action_126 (29#) = happyShift action_14-action_126 (34#) = happyShift action_15-action_126 (41#) = happyShift action_16-action_126 (42#) = happyShift action_17-action_126 (43#) = happyShift action_18-action_126 (49#) = happyShift action_19-action_126 (55#) = happyShift action_20-action_126 (59#) = happyShift action_21-action_126 (60#) = happyShift action_22-action_126 (68#) = happyShift action_23-action_126 (69#) = happyShift action_24-action_126 (73#) = happyShift action_25-action_126 (75#) = happyShift action_26-action_126 (78#) = happyShift action_27-action_126 (79#) = happyShift action_28-action_126 (81#) = happyShift action_29-action_126 (82#) = happyShift action_30-action_126 (83#) = happyShift action_31-action_126 (5#) = happyGoto action_2-action_126 (6#) = happyGoto action_135-action_126 (8#) = happyGoto action_4-action_126 (15#) = happyGoto action_5-action_126 (16#) = happyGoto action_6-action_126 (17#) = happyGoto action_7-action_126 (20#) = happyGoto action_8-action_126 (23#) = happyGoto action_9-action_126 (24#) = happyGoto action_10-action_126 (25#) = happyGoto action_11-action_126 x = happyTcHack x happyFail--action_127 (35#) = happyShift action_134-action_127 x = happyTcHack x happyFail--action_128 (35#) = happyShift action_133-action_128 x = happyTcHack x happyFail--action_129 (74#) = happyShift action_54-action_129 (22#) = happyGoto action_115-action_129 x = happyTcHack x happyReduce_78--action_130 (35#) = happyShift action_132-action_130 (62#) = happyShift action_121-action_130 x = happyTcHack x happyFail--action_131 x = happyTcHack x happyReduce_96--action_132 x = happyTcHack x happyReduce_95--action_133 x = happyTcHack x happyReduce_57--action_134 x = happyTcHack x happyReduce_56--action_135 (40#) = happyShift action_61-action_135 (41#) = happyShift action_62-action_135 (42#) = happyShift action_63-action_135 (43#) = happyShift action_64-action_135 (44#) = happyShift action_65-action_135 (45#) = happyShift action_66-action_135 (46#) = happyShift action_67-action_135 (47#) = happyShift action_68-action_135 (48#) = happyShift action_69-action_135 (49#) = happyShift action_70-action_135 (50#) = happyShift action_71-action_135 (51#) = happyShift action_72-action_135 (52#) = happyShift action_73-action_135 (53#) = happyShift action_74-action_135 (54#) = happyShift action_75-action_135 (55#) = happyShift action_76-action_135 (56#) = happyShift action_77-action_135 (57#) = happyShift action_78-action_135 (58#) = happyShift action_79-action_135 x = happyTcHack x happyReduce_45--action_136 (63#) = happyShift action_175-action_136 x = happyTcHack x happyFail--action_137 (40#) = happyShift action_61-action_137 (41#) = happyShift action_62-action_137 (42#) = happyShift action_63-action_137 (43#) = happyShift action_64-action_137 (44#) = happyShift action_65-action_137 (45#) = happyShift action_66-action_137 (46#) = happyShift action_67-action_137 (47#) = happyShift action_68-action_137 (48#) = happyShift action_69-action_137 (49#) = happyShift action_70-action_137 (50#) = happyShift action_71-action_137 (51#) = happyShift action_72-action_137 (52#) = happyShift action_73-action_137 (53#) = happyShift action_74-action_137 (54#) = happyShift action_75-action_137 (55#) = happyShift action_76-action_137 (56#) = happyShift action_77-action_137 (57#) = happyShift action_78-action_137 (58#) = happyShift action_79-action_137 (76#) = happyShift action_174-action_137 x = happyTcHack x happyReduce_41--action_138 (38#) = happyShift action_172-action_138 (83#) = happyShift action_173-action_138 x = happyTcHack x happyFail--action_139 (47#) = happyShift action_171-action_139 x = happyTcHack x happyFail--action_140 (40#) = happyShift action_61-action_140 (41#) = happyShift action_62-action_140 (42#) = happyShift action_63-action_140 (43#) = happyShift action_64-action_140 (44#) = happyShift action_65-action_140 (45#) = happyShift action_66-action_140 (46#) = happyShift action_67-action_140 (47#) = happyShift action_68-action_140 (48#) = happyShift action_69-action_140 (49#) = happyShift action_70-action_140 (50#) = happyShift action_71-action_140 (51#) = happyShift action_72-action_140 (52#) = happyShift action_73-action_140 (53#) = happyShift action_74-action_140 (54#) = happyShift action_75-action_140 (55#) = happyShift action_76-action_140 (56#) = happyShift action_77-action_140 (57#) = happyShift action_78-action_140 (58#) = happyShift action_79-action_140 x = happyTcHack x happyReduce_36--action_141 (31#) = happyShift action_170-action_141 (40#) = happyShift action_61-action_141 (41#) = happyShift action_62-action_141 (42#) = happyShift action_63-action_141 (43#) = happyShift action_64-action_141 (44#) = happyShift action_65-action_141 (45#) = happyShift action_66-action_141 (46#) = happyShift action_67-action_141 (47#) = happyShift action_68-action_141 (48#) = happyShift action_69-action_141 (49#) = happyShift action_70-action_141 (50#) = happyShift action_71-action_141 (51#) = happyShift action_72-action_141 (52#) = happyShift action_73-action_141 (53#) = happyShift action_74-action_141 (54#) = happyShift action_75-action_141 (55#) = happyShift action_76-action_141 (56#) = happyShift action_77-action_141 (57#) = happyShift action_78-action_141 (58#) = happyShift action_79-action_141 x = happyTcHack x happyFail--action_142 (40#) = happyShift action_61-action_142 (41#) = happyShift action_62-action_142 (42#) = happyShift action_63-action_142 (43#) = happyShift action_64-action_142 (44#) = happyShift action_65-action_142 (45#) = happyShift action_66-action_142 (46#) = happyShift action_67-action_142 (47#) = happyShift action_68-action_142 (48#) = happyShift action_69-action_142 (49#) = happyShift action_70-action_142 (50#) = happyShift action_71-action_142 (51#) = happyShift action_72-action_142 (52#) = happyShift action_73-action_142 (53#) = happyShift action_74-action_142 (54#) = happyShift action_75-action_142 (55#) = happyShift action_76-action_142 (56#) = happyShift action_77-action_142 (57#) = happyShift action_78-action_142 (58#) = happyShift action_79-action_142 x = happyTcHack x happyReduce_5--action_143 (40#) = happyShift action_61-action_143 (41#) = happyShift action_62-action_143 (42#) = happyShift action_63-action_143 (43#) = happyShift action_64-action_143 (44#) = happyShift action_65-action_143 (45#) = happyShift action_66-action_143 (46#) = happyShift action_67-action_143 (47#) = happyShift action_68-action_143 (48#) = happyShift action_69-action_143 (49#) = happyShift action_70-action_143 (50#) = happyShift action_71-action_143 (51#) = happyShift action_72-action_143 (52#) = happyShift action_73-action_143 (53#) = happyShift action_74-action_143 (54#) = happyShift action_75-action_143 (55#) = happyShift action_76-action_143 (56#) = happyShift action_77-action_143 (57#) = happyShift action_78-action_143 (58#) = happyShift action_79-action_143 x = happyTcHack x happyReduce_4--action_144 (61#) = happyShift action_169-action_144 x = happyTcHack x happyFail--action_145 x = happyTcHack x happyReduce_87--action_146 (32#) = happyShift action_53-action_146 x = happyTcHack x happyReduce_83--action_147 (34#) = happyShift action_15-action_147 (43#) = happyShift action_18-action_147 (75#) = happyShift action_26-action_147 (78#) = happyShift action_27-action_147 (79#) = happyShift action_28-action_147 (5#) = happyGoto action_2-action_147 (23#) = happyGoto action_168-action_147 (24#) = happyGoto action_10-action_147 (25#) = happyGoto action_11-action_147 x = happyTcHack x happyFail--action_148 (32#) = happyShift action_53-action_148 x = happyTcHack x happyReduce_82--action_149 (51#) = happyShift action_167-action_149 x = happyTcHack x happyFail--action_150 (37#) = happyShift action_166-action_150 (62#) = happyShift action_121-action_150 x = happyTcHack x happyFail--action_151 x = happyTcHack x happyReduce_70--action_152 (27#) = happyShift action_12-action_152 (28#) = happyShift action_13-action_152 (29#) = happyShift action_14-action_152 (34#) = happyShift action_15-action_152 (41#) = happyShift action_16-action_152 (42#) = happyShift action_17-action_152 (43#) = happyShift action_18-action_152 (49#) = happyShift action_19-action_152 (55#) = happyShift action_20-action_152 (59#) = happyShift action_21-action_152 (60#) = happyShift action_22-action_152 (68#) = happyShift action_23-action_152 (69#) = happyShift action_24-action_152 (73#) = happyShift action_25-action_152 (75#) = happyShift action_26-action_152 (78#) = happyShift action_27-action_152 (79#) = happyShift action_28-action_152 (81#) = happyShift action_29-action_152 (82#) = happyShift action_30-action_152 (83#) = happyShift action_31-action_152 (5#) = happyGoto action_2-action_152 (6#) = happyGoto action_45-action_152 (7#) = happyGoto action_165-action_152 (8#) = happyGoto action_4-action_152 (15#) = happyGoto action_5-action_152 (16#) = happyGoto action_6-action_152 (17#) = happyGoto action_7-action_152 (20#) = happyGoto action_8-action_152 (23#) = happyGoto action_9-action_152 (24#) = happyGoto action_10-action_152 (25#) = happyGoto action_11-action_152 x = happyTcHack x happyFail--action_153 (75#) = happyShift action_164-action_153 x = happyTcHack x happyFail--action_154 x = happyTcHack x happyReduce_69--action_155 x = happyTcHack x happyReduce_68--action_156 (40#) = happyShift action_61-action_156 (41#) = happyShift action_62-action_156 (42#) = happyShift action_63-action_156 (43#) = happyShift action_64-action_156 (44#) = happyShift action_65-action_156 (45#) = happyShift action_66-action_156 (46#) = happyShift action_67-action_156 (47#) = happyShift action_68-action_156 (48#) = happyShift action_69-action_156 (49#) = happyShift action_70-action_156 (50#) = happyShift action_71-action_156 (51#) = happyShift action_72-action_156 (52#) = happyShift action_73-action_156 (53#) = happyShift action_74-action_156 (54#) = happyShift action_75-action_156 (55#) = happyShift action_76-action_156 (56#) = happyShift action_77-action_156 (57#) = happyShift action_78-action_156 (58#) = happyShift action_79-action_156 (66#) = happyShift action_162-action_156 (67#) = happyShift action_163-action_156 (14#) = happyGoto action_161-action_156 x = happyTcHack x happyReduce_55--action_157 (62#) = happyShift action_160-action_157 x = happyTcHack x happyReduce_49--action_158 (27#) = happyShift action_12-action_158 (28#) = happyShift action_13-action_158 (29#) = happyShift action_14-action_158 (34#) = happyShift action_15-action_158 (41#) = happyShift action_16-action_158 (42#) = happyShift action_17-action_158 (43#) = happyShift action_18-action_158 (49#) = happyShift action_19-action_158 (55#) = happyShift action_20-action_158 (59#) = happyShift action_21-action_158 (60#) = happyShift action_22-action_158 (68#) = happyShift action_23-action_158 (69#) = happyShift action_24-action_158 (73#) = happyShift action_25-action_158 (75#) = happyShift action_26-action_158 (78#) = happyShift action_27-action_158 (79#) = happyShift action_28-action_158 (81#) = happyShift action_29-action_158 (82#) = happyShift action_30-action_158 (83#) = happyShift action_31-action_158 (5#) = happyGoto action_2-action_158 (6#) = happyGoto action_159-action_158 (8#) = happyGoto action_4-action_158 (15#) = happyGoto action_5-action_158 (16#) = happyGoto action_6-action_158 (17#) = happyGoto action_7-action_158 (20#) = happyGoto action_8-action_158 (23#) = happyGoto action_9-action_158 (24#) = happyGoto action_10-action_158 (25#) = happyGoto action_11-action_158 x = happyTcHack x happyFail--action_159 (40#) = happyShift action_61-action_159 (41#) = happyShift action_62-action_159 (42#) = happyShift action_63-action_159 (43#) = happyShift action_64-action_159 (44#) = happyShift action_65-action_159 (45#) = happyShift action_66-action_159 (46#) = happyShift action_67-action_159 (47#) = happyShift action_68-action_159 (48#) = happyShift action_69-action_159 (49#) = happyShift action_70-action_159 (50#) = happyShift action_71-action_159 (51#) = happyShift action_72-action_159 (52#) = happyShift action_73-action_159 (53#) = happyShift action_74-action_159 (54#) = happyShift action_75-action_159 (55#) = happyShift action_76-action_159 (56#) = happyShift action_77-action_159 (57#) = happyShift action_78-action_159 (58#) = happyShift action_79-action_159 x = happyTcHack x happyReduce_3--action_160 (27#) = happyShift action_12-action_160 (28#) = happyShift action_13-action_160 (29#) = happyShift action_14-action_160 (34#) = happyShift action_15-action_160 (41#) = happyShift action_16-action_160 (42#) = happyShift action_17-action_160 (43#) = happyShift action_18-action_160 (49#) = happyShift action_19-action_160 (55#) = happyShift action_20-action_160 (59#) = happyShift action_21-action_160 (60#) = happyShift action_22-action_160 (68#) = happyShift action_23-action_160 (69#) = happyShift action_24-action_160 (73#) = happyShift action_25-action_160 (75#) = happyShift action_26-action_160 (78#) = happyShift action_27-action_160 (79#) = happyShift action_28-action_160 (81#) = happyShift action_29-action_160 (82#) = happyShift action_30-action_160 (83#) = happyShift action_31-action_160 (5#) = happyGoto action_2-action_160 (6#) = happyGoto action_185-action_160 (8#) = happyGoto action_4-action_160 (15#) = happyGoto action_5-action_160 (16#) = happyGoto action_6-action_160 (17#) = happyGoto action_7-action_160 (20#) = happyGoto action_8-action_160 (23#) = happyGoto action_9-action_160 (24#) = happyGoto action_10-action_160 (25#) = happyGoto action_11-action_160 x = happyTcHack x happyFail--action_161 x = happyTcHack x happyReduce_51--action_162 x = happyTcHack x happyReduce_53--action_163 x = happyTcHack x happyReduce_54--action_164 (51#) = happyShift action_184-action_164 x = happyTcHack x happyFail--action_165 (37#) = happyShift action_183-action_165 (62#) = happyShift action_121-action_165 x = happyTcHack x happyFail--action_166 x = happyTcHack x happyReduce_63--action_167 x = happyTcHack x happyReduce_59--action_168 (32#) = happyShift action_53-action_168 x = happyTcHack x happyReduce_84--action_169 (27#) = happyShift action_12-action_169 (28#) = happyShift action_13-action_169 (29#) = happyShift action_14-action_169 (34#) = happyShift action_15-action_169 (41#) = happyShift action_16-action_169 (42#) = happyShift action_17-action_169 (43#) = happyShift action_18-action_169 (49#) = happyShift action_19-action_169 (55#) = happyShift action_20-action_169 (59#) = happyShift action_21-action_169 (60#) = happyShift action_22-action_169 (68#) = happyShift action_23-action_169 (69#) = happyShift action_24-action_169 (73#) = happyShift action_25-action_169 (75#) = happyShift action_26-action_169 (78#) = happyShift action_27-action_169 (79#) = happyShift action_28-action_169 (81#) = happyShift action_29-action_169 (82#) = happyShift action_30-action_169 (83#) = happyShift action_31-action_169 (5#) = happyGoto action_2-action_169 (6#) = happyGoto action_182-action_169 (8#) = happyGoto action_4-action_169 (15#) = happyGoto action_5-action_169 (16#) = happyGoto action_6-action_169 (17#) = happyGoto action_7-action_169 (20#) = happyGoto action_8-action_169 (23#) = happyGoto action_9-action_169 (24#) = happyGoto action_10-action_169 (25#) = happyGoto action_11-action_169 x = happyTcHack x happyFail--action_170 (27#) = happyShift action_12-action_170 (28#) = happyShift action_13-action_170 (29#) = happyShift action_14-action_170 (34#) = happyShift action_15-action_170 (41#) = happyShift action_16-action_170 (42#) = happyShift action_17-action_170 (43#) = happyShift action_18-action_170 (49#) = happyShift action_19-action_170 (55#) = happyShift action_20-action_170 (59#) = happyShift action_21-action_170 (60#) = happyShift action_22-action_170 (68#) = happyShift action_23-action_170 (69#) = happyShift action_24-action_170 (73#) = happyShift action_25-action_170 (75#) = happyShift action_26-action_170 (78#) = happyShift action_27-action_170 (79#) = happyShift action_28-action_170 (81#) = happyShift action_29-action_170 (82#) = happyShift action_30-action_170 (83#) = happyShift action_31-action_170 (5#) = happyGoto action_2-action_170 (6#) = happyGoto action_181-action_170 (8#) = happyGoto action_4-action_170 (15#) = happyGoto action_5-action_170 (16#) = happyGoto action_6-action_170 (17#) = happyGoto action_7-action_170 (20#) = happyGoto action_8-action_170 (23#) = happyGoto action_9-action_170 (24#) = happyGoto action_10-action_170 (25#) = happyGoto action_11-action_170 x = happyTcHack x happyFail--action_171 (38#) = happyShift action_179-action_171 (83#) = happyShift action_180-action_171 x = happyTcHack x happyFail--action_172 (27#) = happyShift action_12-action_172 (28#) = happyShift action_13-action_172 (29#) = happyShift action_14-action_172 (34#) = happyShift action_15-action_172 (41#) = happyShift action_16-action_172 (42#) = happyShift action_17-action_172 (43#) = happyShift action_18-action_172 (49#) = happyShift action_19-action_172 (55#) = happyShift action_20-action_172 (59#) = happyShift action_21-action_172 (60#) = happyShift action_22-action_172 (68#) = happyShift action_23-action_172 (69#) = happyShift action_24-action_172 (73#) = happyShift action_25-action_172 (75#) = happyShift action_26-action_172 (78#) = happyShift action_27-action_172 (79#) = happyShift action_28-action_172 (81#) = happyShift action_29-action_172 (82#) = happyShift action_30-action_172 (83#) = happyShift action_31-action_172 (5#) = happyGoto action_2-action_172 (6#) = happyGoto action_178-action_172 (8#) = happyGoto action_4-action_172 (15#) = happyGoto action_5-action_172 (16#) = happyGoto action_6-action_172 (17#) = happyGoto action_7-action_172 (20#) = happyGoto action_8-action_172 (23#) = happyGoto action_9-action_172 (24#) = happyGoto action_10-action_172 (25#) = happyGoto action_11-action_172 x = happyTcHack x happyFail--action_173 x = happyTcHack x happyReduce_71--action_174 (79#) = happyShift action_28-action_174 (5#) = happyGoto action_177-action_174 x = happyTcHack x happyFail--action_175 (27#) = happyShift action_12-action_175 (28#) = happyShift action_13-action_175 (29#) = happyShift action_14-action_175 (34#) = happyShift action_15-action_175 (41#) = happyShift action_16-action_175 (42#) = happyShift action_17-action_175 (43#) = happyShift action_18-action_175 (49#) = happyShift action_19-action_175 (55#) = happyShift action_20-action_175 (59#) = happyShift action_21-action_175 (60#) = happyShift action_22-action_175 (68#) = happyShift action_23-action_175 (69#) = happyShift action_24-action_175 (73#) = happyShift action_25-action_175 (75#) = happyShift action_26-action_175 (78#) = happyShift action_27-action_175 (79#) = happyShift action_28-action_175 (81#) = happyShift action_29-action_175 (82#) = happyShift action_30-action_175 (83#) = happyShift action_31-action_175 (5#) = happyGoto action_2-action_175 (6#) = happyGoto action_176-action_175 (8#) = happyGoto action_4-action_175 (15#) = happyGoto action_5-action_175 (16#) = happyGoto action_6-action_175 (17#) = happyGoto action_7-action_175 (20#) = happyGoto action_8-action_175 (23#) = happyGoto action_9-action_175 (24#) = happyGoto action_10-action_175 (25#) = happyGoto action_11-action_175 x = happyTcHack x happyFail--action_176 (40#) = happyShift action_61-action_176 (41#) = happyShift action_62-action_176 (42#) = happyShift action_63-action_176 (43#) = happyShift action_64-action_176 (44#) = happyShift action_65-action_176 (45#) = happyShift action_66-action_176 (46#) = happyShift action_67-action_176 (47#) = happyShift action_68-action_176 (48#) = happyShift action_69-action_176 (49#) = happyShift action_70-action_176 (50#) = happyShift action_71-action_176 (51#) = happyShift action_72-action_176 (52#) = happyShift action_73-action_176 (53#) = happyShift action_74-action_176 (54#) = happyShift action_75-action_176 (55#) = happyShift action_76-action_176 (56#) = happyShift action_77-action_176 (57#) = happyShift action_78-action_176 (58#) = happyShift action_79-action_176 x = happyTcHack x happyReduce_46--action_177 x = happyTcHack x happyReduce_42--action_178 (39#) = happyShift action_189-action_178 (40#) = happyShift action_61-action_178 (41#) = happyShift action_62-action_178 (42#) = happyShift action_63-action_178 (43#) = happyShift action_64-action_178 (44#) = happyShift action_65-action_178 (45#) = happyShift action_66-action_178 (46#) = happyShift action_67-action_178 (47#) = happyShift action_68-action_178 (48#) = happyShift action_69-action_178 (49#) = happyShift action_70-action_178 (50#) = happyShift action_71-action_178 (51#) = happyShift action_72-action_178 (52#) = happyShift action_73-action_178 (53#) = happyShift action_74-action_178 (54#) = happyShift action_75-action_178 (55#) = happyShift action_76-action_178 (56#) = happyShift action_77-action_178 (57#) = happyShift action_78-action_178 (58#) = happyShift action_79-action_178 x = happyTcHack x happyFail--action_179 (27#) = happyShift action_12-action_179 (28#) = happyShift action_13-action_179 (29#) = happyShift action_14-action_179 (34#) = happyShift action_15-action_179 (41#) = happyShift action_16-action_179 (42#) = happyShift action_17-action_179 (43#) = happyShift action_18-action_179 (49#) = happyShift action_19-action_179 (55#) = happyShift action_20-action_179 (59#) = happyShift action_21-action_179 (60#) = happyShift action_22-action_179 (68#) = happyShift action_23-action_179 (69#) = happyShift action_24-action_179 (73#) = happyShift action_25-action_179 (75#) = happyShift action_26-action_179 (78#) = happyShift action_27-action_179 (79#) = happyShift action_28-action_179 (81#) = happyShift action_29-action_179 (82#) = happyShift action_30-action_179 (83#) = happyShift action_31-action_179 (5#) = happyGoto action_2-action_179 (6#) = happyGoto action_188-action_179 (8#) = happyGoto action_4-action_179 (15#) = happyGoto action_5-action_179 (16#) = happyGoto action_6-action_179 (17#) = happyGoto action_7-action_179 (20#) = happyGoto action_8-action_179 (23#) = happyGoto action_9-action_179 (24#) = happyGoto action_10-action_179 (25#) = happyGoto action_11-action_179 x = happyTcHack x happyFail--action_180 x = happyTcHack x happyReduce_73--action_181 (40#) = happyShift action_61-action_181 (41#) = happyShift action_62-action_181 (42#) = happyShift action_63-action_181 (43#) = happyShift action_64-action_181 (44#) = happyShift action_65-action_181 (45#) = happyShift action_66-action_181 (46#) = happyShift action_67-action_181 (47#) = happyShift action_68-action_181 (48#) = happyShift action_69-action_181 (49#) = happyShift action_70-action_181 (50#) = happyShift action_71-action_181 (51#) = happyShift action_72-action_181 (52#) = happyShift action_73-action_181 (53#) = happyShift action_74-action_181 (54#) = happyShift action_75-action_181 (55#) = happyShift action_76-action_181 (56#) = happyShift action_77-action_181 (57#) = happyShift action_78-action_181 (58#) = happyShift action_79-action_181 x = happyTcHack x happyReduce_6--action_182 (40#) = happyShift action_61-action_182 (41#) = happyShift action_62-action_182 (42#) = happyShift action_63-action_182 (43#) = happyShift action_64-action_182 (44#) = happyShift action_65-action_182 (45#) = happyShift action_66-action_182 (46#) = happyShift action_67-action_182 (47#) = happyShift action_68-action_182 (48#) = happyShift action_69-action_182 (49#) = happyShift action_70-action_182 (50#) = happyShift action_71-action_182 (51#) = happyShift action_72-action_182 (52#) = happyShift action_73-action_182 (53#) = happyShift action_74-action_182 (54#) = happyShift action_75-action_182 (55#) = happyShift action_76-action_182 (56#) = happyShift action_77-action_182 (57#) = happyShift action_78-action_182 (58#) = happyShift action_79-action_182 (76#) = happyShift action_187-action_182 x = happyTcHack x happyReduce_43--action_183 x = happyTcHack x happyReduce_67--action_184 x = happyTcHack x happyReduce_58--action_185 (40#) = happyShift action_61-action_185 (41#) = happyShift action_62-action_185 (42#) = happyShift action_63-action_185 (43#) = happyShift action_64-action_185 (44#) = happyShift action_65-action_185 (45#) = happyShift action_66-action_185 (46#) = happyShift action_67-action_185 (47#) = happyShift action_68-action_185 (48#) = happyShift action_69-action_185 (49#) = happyShift action_70-action_185 (50#) = happyShift action_71-action_185 (51#) = happyShift action_72-action_185 (52#) = happyShift action_73-action_185 (53#) = happyShift action_74-action_185 (54#) = happyShift action_75-action_185 (55#) = happyShift action_76-action_185 (56#) = happyShift action_77-action_185 (57#) = happyShift action_78-action_185 (58#) = happyShift action_79-action_185 (66#) = happyShift action_162-action_185 (67#) = happyShift action_163-action_185 (14#) = happyGoto action_186-action_185 x = happyTcHack x happyReduce_55--action_186 x = happyTcHack x happyReduce_52--action_187 (79#) = happyShift action_28-action_187 (5#) = happyGoto action_191-action_187 x = happyTcHack x happyFail--action_188 (39#) = happyShift action_190-action_188 (40#) = happyShift action_61-action_188 (41#) = happyShift action_62-action_188 (42#) = happyShift action_63-action_188 (43#) = happyShift action_64-action_188 (44#) = happyShift action_65-action_188 (45#) = happyShift action_66-action_188 (46#) = happyShift action_67-action_188 (47#) = happyShift action_68-action_188 (48#) = happyShift action_69-action_188 (49#) = happyShift action_70-action_188 (50#) = happyShift action_71-action_188 (51#) = happyShift action_72-action_188 (52#) = happyShift action_73-action_188 (53#) = happyShift action_74-action_188 (54#) = happyShift action_75-action_188 (55#) = happyShift action_76-action_188 (56#) = happyShift action_77-action_188 (57#) = happyShift action_78-action_188 (58#) = happyShift action_79-action_188 x = happyTcHack x happyFail--action_189 x = happyTcHack x happyReduce_72--action_190 x = happyTcHack x happyReduce_74--action_191 x = happyTcHack x happyReduce_44--happyReduce_1 = happySpecReduce_1 4# happyReduction_1-happyReduction_1 happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn4- (happy_var_1- )}--happyReduce_2 = happySpecReduce_1 5# happyReduction_2-happyReduction_2 happy_x_1- = case happyOutTok happy_x_1 of { (Variable happy_var_1) -> - happyIn5- (Avar happy_var_1- )}--happyReduce_3 = happyReduce 5# 6# happyReduction_3-happyReduction_3 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut11 happy_x_2 of { happy_var_2 -> - case happyOut12 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn6- ((snd happy_var_3) (happy_var_1 (happy_var_2 ((fst happy_var_3) happy_var_5)))- ) `HappyStk` happyRest}}}}--happyReduce_4 = happyReduce 4# 6# happyReduction_4-happyReduction_4 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut9 happy_x_2 of { happy_var_2 -> - case happyOut6 happy_x_4 of { happy_var_4 -> - happyIn6- (call "some" [happy_var_2 happy_var_4]- ) `HappyStk` happyRest}}--happyReduce_5 = happyReduce 4# 6# happyReduction_5-happyReduction_5 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut9 happy_x_2 of { happy_var_2 -> - case happyOut6 happy_x_4 of { happy_var_4 -> - happyIn6- (call "not" [call "some" [happy_var_2 (call "not" [happy_var_4])]]- ) `HappyStk` happyRest}}--happyReduce_6 = happyReduce 6# 6# happyReduction_6-happyReduction_6 (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 happyOut6 happy_x_2 of { happy_var_2 -> - case happyOut6 happy_x_4 of { happy_var_4 -> - case happyOut6 happy_x_6 of { happy_var_6 -> - happyIn6- (call "if" [happy_var_2,happy_var_4,happy_var_6]- ) `HappyStk` happyRest}}}--happyReduce_7 = happySpecReduce_1 6# happyReduction_7-happyReduction_7 happy_x_1- = case happyOut20 happy_x_1 of { happy_var_1 -> - happyIn6- (happy_var_1- )}--happyReduce_8 = happySpecReduce_1 6# happyReduction_8-happyReduction_8 happy_x_1- = case happyOut16 happy_x_1 of { happy_var_1 -> - happyIn6- (happy_var_1- )}--happyReduce_9 = happySpecReduce_1 6# happyReduction_9-happyReduction_9 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn6- (happy_var_1- )}--happyReduce_10 = happySpecReduce_3 6# happyReduction_10-happyReduction_10 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "to" [happy_var_1,happy_var_3]- )}}--happyReduce_11 = happySpecReduce_3 6# happyReduction_11-happyReduction_11 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "+" [happy_var_1,happy_var_3]- )}}--happyReduce_12 = happySpecReduce_3 6# happyReduction_12-happyReduction_12 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "-" [happy_var_1,happy_var_3]- )}}--happyReduce_13 = happySpecReduce_3 6# happyReduction_13-happyReduction_13 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "*" [happy_var_1,happy_var_3]- )}}--happyReduce_14 = happySpecReduce_3 6# happyReduction_14-happyReduction_14 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "div" [happy_var_1,happy_var_3]- )}}--happyReduce_15 = happySpecReduce_3 6# happyReduction_15-happyReduction_15 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "idiv" [happy_var_1,happy_var_3]- )}}--happyReduce_16 = happySpecReduce_3 6# happyReduction_16-happyReduction_16 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "mod" [happy_var_1,happy_var_3]- )}}--happyReduce_17 = happySpecReduce_3 6# happyReduction_17-happyReduction_17 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "=" [happy_var_1,happy_var_3]- )}}--happyReduce_18 = happySpecReduce_3 6# happyReduction_18-happyReduction_18 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "!=" [happy_var_1,happy_var_3]- )}}--happyReduce_19 = happySpecReduce_3 6# happyReduction_19-happyReduction_19 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "<" [happy_var_1,happy_var_3]- )}}--happyReduce_20 = happySpecReduce_3 6# happyReduction_20-happyReduction_20 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "<=" [happy_var_1,happy_var_3]- )}}--happyReduce_21 = happySpecReduce_3 6# happyReduction_21-happyReduction_21 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call ">" [happy_var_1,happy_var_3]- )}}--happyReduce_22 = happySpecReduce_3 6# happyReduction_22-happyReduction_22 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call ">=" [happy_var_1,happy_var_3]- )}}--happyReduce_23 = happySpecReduce_3 6# happyReduction_23-happyReduction_23 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "and" [happy_var_1,happy_var_3]- )}}--happyReduce_24 = happySpecReduce_3 6# happyReduction_24-happyReduction_24 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "or" [happy_var_1,happy_var_3]- )}}--happyReduce_25 = happySpecReduce_3 6# happyReduction_25-happyReduction_25 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "not" [happy_var_1,happy_var_3]- )}}--happyReduce_26 = happySpecReduce_3 6# happyReduction_26-happyReduction_26 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "union" [happy_var_1,happy_var_3]- )}}--happyReduce_27 = happySpecReduce_3 6# happyReduction_27-happyReduction_27 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "itersect" [happy_var_1,happy_var_3]- )}}--happyReduce_28 = happySpecReduce_3 6# happyReduction_28-happyReduction_28 happy_x_3- happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn6- (call "except" [happy_var_1,happy_var_3]- )}}--happyReduce_29 = happySpecReduce_2 6# happyReduction_29-happyReduction_29 happy_x_2- happy_x_1- = case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn6- (call "uplus" [happy_var_2]- )}--happyReduce_30 = happySpecReduce_2 6# happyReduction_30-happyReduction_30 happy_x_2- happy_x_1- = case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn6- (call "uminus" [happy_var_2]- )}--happyReduce_31 = happySpecReduce_2 6# happyReduction_31-happyReduction_31 happy_x_2- happy_x_1- = case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn6- (call "not" [happy_var_2]- )}--happyReduce_32 = happySpecReduce_1 6# happyReduction_32-happyReduction_32 happy_x_1- = case happyOutTok happy_x_1 of { (TString happy_var_1) -> - happyIn6- (Astring happy_var_1- )}--happyReduce_33 = happySpecReduce_1 6# happyReduction_33-happyReduction_33 happy_x_1- = case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> - happyIn6- (Aint happy_var_1- )}--happyReduce_34 = happySpecReduce_1 6# happyReduction_34-happyReduction_34 happy_x_1- = case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> - happyIn6- (Afloat happy_var_1- )}--happyReduce_35 = happySpecReduce_1 7# happyReduction_35-happyReduction_35 happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn7- ([happy_var_1]- )}--happyReduce_36 = happySpecReduce_3 7# happyReduction_36-happyReduction_36 happy_x_3- happy_x_2- happy_x_1- = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn7- (happy_var_1++[happy_var_3]- )}}--happyReduce_37 = happySpecReduce_2 8# happyReduction_37-happyReduction_37 happy_x_2- happy_x_1- = case happyOut9 happy_x_2 of { happy_var_2 -> - happyIn8- (happy_var_2- )}--happyReduce_38 = happySpecReduce_2 8# happyReduction_38-happyReduction_38 happy_x_2- happy_x_1- = case happyOut10 happy_x_2 of { happy_var_2 -> - happyIn8- (happy_var_2- )}--happyReduce_39 = happySpecReduce_3 8# happyReduction_39-happyReduction_39 happy_x_3- happy_x_2- happy_x_1- = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_3 of { happy_var_3 -> - happyIn8- (happy_var_1 . happy_var_3- )}}--happyReduce_40 = happySpecReduce_3 8# happyReduction_40-happyReduction_40 happy_x_3- happy_x_2- happy_x_1- = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut10 happy_x_3 of { happy_var_3 -> - happyIn8- (happy_var_1 . happy_var_3- )}}--happyReduce_41 = happySpecReduce_3 9# happyReduction_41-happyReduction_41 happy_x_3- happy_x_2- happy_x_1- = case happyOut5 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn9- (\x -> Ast "for" [happy_var_1,Avar "$",happy_var_3,x]- )}}--happyReduce_42 = happyReduce 5# 9# happyReduction_42-happyReduction_42 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut5 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut5 happy_x_5 of { happy_var_5 -> - happyIn9- (\x -> Ast "for" [happy_var_1,happy_var_5,happy_var_3,x]- ) `HappyStk` happyRest}}}--happyReduce_43 = happyReduce 5# 9# happyReduction_43-happyReduction_43 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut5 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn9- (\x -> happy_var_1(Ast "for" [happy_var_3,Avar "$",happy_var_5,x])- ) `HappyStk` happyRest}}}--happyReduce_44 = happyReduce 7# 9# happyReduction_44-happyReduction_44 (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 happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut5 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - case happyOut5 happy_x_7 of { happy_var_7 -> - happyIn9- (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_7,happy_var_5,x])- ) `HappyStk` happyRest}}}}--happyReduce_45 = happySpecReduce_3 10# happyReduction_45-happyReduction_45 happy_x_3- happy_x_2- happy_x_1- = case happyOut5 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn10- (\x -> Ast "let" [happy_var_1,happy_var_3,x]- )}}--happyReduce_46 = happyReduce 5# 10# happyReduction_46-happyReduction_46 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut5 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn10- (\x -> happy_var_1(Ast "let" [happy_var_3,happy_var_5,x])- ) `HappyStk` happyRest}}}--happyReduce_47 = happySpecReduce_2 11# happyReduction_47-happyReduction_47 happy_x_2- happy_x_1- = case happyOut6 happy_x_2 of { happy_var_2 -> - happyIn11- (\x -> Ast "predicate" [happy_var_2,x]- )}--happyReduce_48 = happySpecReduce_0 11# happyReduction_48-happyReduction_48 = happyIn11- (id- )--happyReduce_49 = happySpecReduce_2 12# happyReduction_49-happyReduction_49 happy_x_2- happy_x_1- = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn12- ((\x -> Ast "sortTuple" (x:(fst happy_var_2)),- \x -> Ast "sort" (x:(snd happy_var_2)))- )}--happyReduce_50 = happySpecReduce_0 12# happyReduction_50-happyReduction_50 = happyIn12- ((id,id)- )--happyReduce_51 = happySpecReduce_2 13# happyReduction_51-happyReduction_51 happy_x_2- happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut14 happy_x_2 of { happy_var_2 -> - happyIn13- (([happy_var_1],[happy_var_2])- )}}--happyReduce_52 = happyReduce 4# 13# happyReduction_52-happyReduction_52 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut13 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut14 happy_x_4 of { happy_var_4 -> - happyIn13- (((fst happy_var_1)++[happy_var_3],(snd happy_var_1)++[happy_var_4])- ) `HappyStk` happyRest}}}--happyReduce_53 = happySpecReduce_1 14# happyReduction_53-happyReduction_53 happy_x_1- = happyIn14- (Avar "ascending"- )--happyReduce_54 = happySpecReduce_1 14# happyReduction_54-happyReduction_54 happy_x_1- = happyIn14- (Avar "descending"- )--happyReduce_55 = happySpecReduce_0 14# happyReduction_55-happyReduction_55 = happyIn14- (Avar "ascending"- )--happyReduce_56 = happyReduce 4# 15# happyReduction_56-happyReduction_56 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - happyIn15- (call "element" [Avar happy_var_3]- ) `HappyStk` happyRest}--happyReduce_57 = happyReduce 4# 15# happyReduction_57-happyReduction_57 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - happyIn15- (call "attribute" [Avar happy_var_3]- ) `HappyStk` happyRest}--happyReduce_58 = happyReduce 6# 16# happyReduction_58-happyReduction_58 (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 happyOut17 happy_x_1 of { happy_var_1 -> - case happyOut18 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_5 of { (QName happy_var_5) -> - happyIn16- (if head happy_var_1 == Astring happy_var_5- then Ast "construction" (happy_var_1++[concatAll happy_var_3])- else error("Unmatched tags in element construction: "++happy_var_5)- ) `HappyStk` happyRest}}}--happyReduce_59 = happyReduce 5# 16# happyReduction_59-happyReduction_59 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut17 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_4 of { (QName happy_var_4) -> - happyIn16- (if head happy_var_1 == Astring happy_var_4- then Ast "construction" (happy_var_1++[call "empty" []])- else error("Unmatched tags in element construction: "++happy_var_4)- ) `HappyStk` happyRest}}--happyReduce_60 = happySpecReduce_2 16# happyReduction_60-happyReduction_60 happy_x_2- happy_x_1- = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn16- (Ast "construction" (happy_var_1++[call "empty" []])- )}--happyReduce_61 = happySpecReduce_2 17# happyReduction_61-happyReduction_61 happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { (QName happy_var_2) -> - happyIn17- ([Astring happy_var_2,Ast "attributes" []]- )}--happyReduce_62 = happySpecReduce_3 17# happyReduction_62-happyReduction_62 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn17- ([Astring happy_var_2,Ast "attributes" happy_var_3]- )}}--happyReduce_63 = happySpecReduce_3 18# happyReduction_63-happyReduction_63 happy_x_3- happy_x_2- happy_x_1- = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn18- (happy_var_2- )}--happyReduce_64 = happySpecReduce_1 18# happyReduction_64-happyReduction_64 happy_x_1- = case happyOutTok happy_x_1 of { (TString happy_var_1) -> - happyIn18- ([Astring happy_var_1]- )}--happyReduce_65 = happySpecReduce_1 18# happyReduction_65-happyReduction_65 happy_x_1- = case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> - happyIn18- ([Astring happy_var_1]- )}--happyReduce_66 = happySpecReduce_1 18# happyReduction_66-happyReduction_66 happy_x_1- = case happyOut16 happy_x_1 of { happy_var_1 -> - happyIn18- ([happy_var_1]- )}--happyReduce_67 = happyReduce 4# 18# happyReduction_67-happyReduction_67 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn18- (happy_var_1++happy_var_3- ) `HappyStk` happyRest}}--happyReduce_68 = happySpecReduce_2 18# happyReduction_68-happyReduction_68 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TString happy_var_2) -> - happyIn18- (happy_var_1++[Astring happy_var_2]- )}}--happyReduce_69 = happySpecReduce_2 18# happyReduction_69-happyReduction_69 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (XMLtext happy_var_2) -> - happyIn18- (happy_var_1++[Astring happy_var_2]- )}}--happyReduce_70 = happySpecReduce_2 18# happyReduction_70-happyReduction_70 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut16 happy_x_2 of { happy_var_2 -> - happyIn18- (happy_var_1++[happy_var_2]- )}}--happyReduce_71 = happySpecReduce_3 19# happyReduction_71-happyReduction_71 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOutTok happy_x_3 of { (TString happy_var_3) -> - happyIn19- ([Ast "pair" [Astring happy_var_1,Astring happy_var_3]]- )}}--happyReduce_72 = happyReduce 5# 19# happyReduction_72-happyReduction_72 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOut6 happy_x_4 of { happy_var_4 -> - happyIn19- ([Ast "pair" [Astring happy_var_1,happy_var_4]]- ) `HappyStk` happyRest}}--happyReduce_73 = happyReduce 4# 19# happyReduction_73-happyReduction_73 (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 happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOutTok happy_x_4 of { (TString happy_var_4) -> - happyIn19- ((Ast "pair" [Astring happy_var_2,Astring happy_var_4]):happy_var_1- ) `HappyStk` happyRest}}}--happyReduce_74 = happyReduce 6# 19# happyReduction_74-happyReduction_74 (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 happyOut19 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn19- ((Ast "pair" [Astring happy_var_2,happy_var_5]):happy_var_1- ) `HappyStk` happyRest}}}--happyReduce_75 = happySpecReduce_1 20# happyReduction_75-happyReduction_75 happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - happyIn20- (happy_var_1 "child" (Avar ".")- )}--happyReduce_76 = happySpecReduce_2 20# happyReduction_76-happyReduction_76 happy_x_2- happy_x_1- = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn20- (happy_var_2 "attribute" (Avar ".")- )}--happyReduce_77 = happySpecReduce_2 20# happyReduction_77-happyReduction_77 happy_x_2- happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - case happyOut21 happy_x_2 of { happy_var_2 -> - happyIn20- (happy_var_2(happy_var_1 "child" (Avar "."))- )}}--happyReduce_78 = happySpecReduce_3 20# happyReduction_78-happyReduction_78 happy_x_3- happy_x_2- happy_x_1- = case happyOut23 happy_x_2 of { happy_var_2 -> - case happyOut21 happy_x_3 of { happy_var_3 -> - happyIn20- (happy_var_3(happy_var_2 "attribute" (Avar "."))- )}}--happyReduce_79 = happySpecReduce_1 21# happyReduction_79-happyReduction_79 happy_x_1- = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn21- (happy_var_1- )}--happyReduce_80 = happySpecReduce_2 21# happyReduction_80-happyReduction_80 happy_x_2- happy_x_1- = case happyOut21 happy_x_1 of { happy_var_1 -> - case happyOut22 happy_x_2 of { happy_var_2 -> - happyIn21- (happy_var_2 . happy_var_1- )}}--happyReduce_81 = happySpecReduce_2 22# happyReduction_81-happyReduction_81 happy_x_2- happy_x_1- = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn22- (\e -> happy_var_2 "child" e- )}--happyReduce_82 = happySpecReduce_3 22# happyReduction_82-happyReduction_82 happy_x_3- happy_x_2- happy_x_1- = case happyOut23 happy_x_3 of { happy_var_3 -> - happyIn22- (\e -> happy_var_3 "attribute" e- )}--happyReduce_83 = happySpecReduce_3 22# happyReduction_83-happyReduction_83 happy_x_3- happy_x_2- happy_x_1- = case happyOut23 happy_x_3 of { happy_var_3 -> - happyIn22- (\e -> happy_var_3 "descendant" e- )}--happyReduce_84 = happyReduce 4# 22# happyReduction_84-happyReduction_84 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut23 happy_x_4 of { happy_var_4 -> - happyIn22- (\e -> happy_var_4 "descendant_attribute" e- ) `HappyStk` happyRest}--happyReduce_85 = happySpecReduce_2 22# happyReduction_85-happyReduction_85 happy_x_2- happy_x_1- = happyIn22- (\e -> call "parent" [e]- )--happyReduce_86 = happySpecReduce_1 23# happyReduction_86-happyReduction_86 happy_x_1- = case happyOut24 happy_x_1 of { happy_var_1 -> - happyIn23- (happy_var_1- )}--happyReduce_87 = happyReduce 4# 23# happyReduction_87-happyReduction_87 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut23 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn23- (\t e -> Ast "predicate" [happy_var_3,happy_var_1 t e]- ) `HappyStk` happyRest}}--happyReduce_88 = happySpecReduce_1 24# happyReduction_88-happyReduction_88 happy_x_1- = case happyOut25 happy_x_1 of { happy_var_1 -> - happyIn24- (\t e -> happy_var_1 t e- )}--happyReduce_89 = happySpecReduce_1 24# happyReduction_89-happyReduction_89 happy_x_1- = happyIn24- (\t e -> call t [Astring "*",e]- )--happyReduce_90 = happySpecReduce_1 24# happyReduction_90-happyReduction_90 happy_x_1- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - happyIn24- (\t e -> call t [Astring happy_var_1,e]- )}--happyReduce_91 = happySpecReduce_1 25# happyReduction_91-happyReduction_91 happy_x_1- = case happyOut5 happy_x_1 of { happy_var_1 -> - happyIn25- (\_ _ -> happy_var_1- )}--happyReduce_92 = happySpecReduce_1 25# happyReduction_92-happyReduction_92 happy_x_1- = happyIn25- (\_ e -> e- )--happyReduce_93 = happySpecReduce_3 25# happyReduction_93-happyReduction_93 happy_x_3- happy_x_2- happy_x_1- = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn25- (\_ _ -> concatAll happy_var_2- )}--happyReduce_94 = happySpecReduce_2 25# happyReduction_94-happyReduction_94 happy_x_2- happy_x_1- = happyIn25- (\_ _ -> call "empty" []- )--happyReduce_95 = happyReduce 4# 25# happyReduction_95-happyReduction_95 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn25- (\_ _ -> call happy_var_1 happy_var_3- ) `HappyStk` happyRest}}--happyReduce_96 = happySpecReduce_3 25# happyReduction_96-happyReduction_96 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - happyIn25- (if elem happy_var_1 ["text"]- then \_ e -> call happy_var_1 [e]- else \_ _ -> call happy_var_1 []- )}--happyNewToken action sts stk [] =- action 84# 84# notHappyAtAll (HappyState action) sts stk []--happyNewToken action sts stk (tk:tks) =- let cont i = action i i tk (HappyState action) sts stk tks in- case tk of {- RETURN -> cont 26#;- SOME -> cont 27#;- EVERY -> cont 28#;- IF -> cont 29#;- THEN -> cont 30#;- ELSE -> cont 31#;- LB -> cont 32#;- RB -> cont 33#;- LP -> cont 34#;- RP -> cont 35#;- LSB -> cont 36#;- RSB -> cont 37#;- LESCAPE -> cont 38#;- RESCAPE -> cont 39#;- TO -> cont 40#;- PLUS -> cont 41#;- MINUS -> cont 42#;- TIMES -> cont 43#;- DIV -> cont 44#;- IDIV -> cont 45#;- MOD -> cont 46#;- TEQ -> cont 47#;- TNEQ -> cont 48#;- TLT -> cont 49#;- LEQ -> cont 50#;- TGT -> cont 51#;- GEQ -> cont 52#;- AND -> cont 53#;- OR -> cont 54#;- NOT -> cont 55#;- UNION -> cont 56#;- INTERSECT -> cont 57#;- EXCEPT -> cont 58#;- FOR -> cont 59#;- LET -> cont 60#;- IN -> cont 61#;- COMMA -> cont 62#;- ASSIGN -> cont 63#;- WHERE -> cont 64#;- ORDERBY -> cont 65#;- ASCENDING -> cont 66#;- DESCENDING -> cont 67#;- ELEMENT -> cont 68#;- ATTRIBUTE -> cont 69#;- STAG -> cont 70#;- ETAG -> cont 71#;- SATISFIES -> cont 72#;- ATSIGN -> cont 73#;- SLASH -> cont 74#;- QName happy_dollar_dollar -> cont 75#;- AT -> cont 76#;- DOTS -> cont 77#;- DOT -> cont 78#;- Variable happy_dollar_dollar -> cont 79#;- XMLtext happy_dollar_dollar -> cont 80#;- TInteger happy_dollar_dollar -> cont 81#;- TFloat happy_dollar_dollar -> cont 82#;- TString happy_dollar_dollar -> cont 83#;- _ -> 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 . parseError--parse tks = happyRunIdentity happySomeParser where- happySomeParser = happyThen (happyParse action_0 tks) (\x -> happyReturn (happyOut4 x))--happySeq = happyDontSeq----- Abstract Syntax Tree for XQueries-data Ast = Ast String [Ast]- | Avar String- | Aint Int- | Afloat Float- | Astring String- deriving Eq---instance Show Ast- where show (Ast s []) = s ++ "()"- show (Ast s (x:xs)) = s ++ "(" ++ (show x)- ++ (foldr (\a r -> ","++(show a)++r) "" xs)- ++ ")"- show (Avar s) = s- show (Aint n) = show n- show (Afloat n) = show n- show (Astring s) = "\'" ++ s ++ "\'"---call :: String -> [Ast] -> Ast-call name args = Ast "call" ((Avar name):args)---concatAll :: [Ast] -> Ast-concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs-concatAll _ = call "empty" []---parseError tk = error ("Parse error: "++(show (take 10 tk)))---data Token- = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB- | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD- | TEQ | TNEQ | TLT | LEQ | TGT | GEQ | AND | OR | NOT | UNION | INTERSECT- | EXCEPT | FOR | LET | IN | COMMA | ASSIGN | WHERE | ORDERBY | ASCENDING- | DESCENDING | ELEMENT | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN- | SLASH | DEFINE | FUNCTION | AT | DOT | DOTS | TokenEOF- | QName String | Variable String | XMLtext String | TInteger Int- | TFloat Float | TString String- deriving Show---scan :: String -> [Token]-scan cs = lexer cs [0]---xmlText "" = []-xmlText text = [XMLtext text]---- scans XML PCDATA and returns an XMLtext token with the PCData text-xml :: String -> String -> [Int] -> [Token]-xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n))-xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n)-xml ('<':cs) text (k:n) = (xmlText text)++(TLT : lexer cs (k+2:n))-xml ('\'':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)-xml (c:cs) text n = xml cs (text++[c]) n-xml [] text _ = xmlText text---isQN c = elem c "_:-" || isDigit c || isAlpha c--isVar c = elem c "_" || isDigit c || isAlpha c---- the XQuery scanner-lexer :: String -> [Int] -> [Token]-lexer [] [0] = []-lexer [] _ = error("Unbalanced tags")-lexer (' ':'>':' ':cs) n = TGT : lexer cs n-lexer (c:cs) n- | isSpace c = lexer cs n- | isAlpha c = lexVar (c:cs) n- | isDigit c = lexNum (c:cs) n-lexer ('$':c:cs) n | isAlpha c- = let (var,rest) = span isVar (c:cs)- in (Variable var) : lexer rest n-lexer ('\'':'{':cs) n = LESCAPE : lexer cs n-lexer (':':'=':cs) n = ASSIGN : lexer cs n-lexer ('<':'/':cs) n = STAG : lexer cs n-lexer ('<':'=':cs) n = LEQ : lexer cs n-lexer ('>':'=':cs) n = GEQ : lexer cs n-lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)-lexer ('.':'.':cs) n = DOTS : lexer cs n-lexer ('.':cs) n = DOT : lexer cs n-lexer ('}':'\'':cs) n = RESCAPE : lexer cs n-lexer ('!':'=':cs) n = TNEQ : lexer cs n-lexer ('\'':cs) n = lexString cs n-lexer ('[':cs) n = LB : lexer cs n-lexer (']':cs) n = RB : lexer cs n-lexer ('(':cs) n = LP : lexer cs n-lexer (')':cs) n = RP : lexer cs n-lexer ('}':cs) (_:n) = RSB : xml cs "" n-lexer ('+':cs) n = PLUS : lexer cs n-lexer ('-':cs) n = MINUS : lexer cs n-lexer ('*':cs) n = TIMES : lexer cs n-lexer ('=':cs) n = TEQ : lexer cs n-lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n-lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n)-lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (k-1:n) else xml cs "" (k-1:n))-lexer (',':cs) n = COMMA : lexer cs n-lexer ('@':cs) n = ATSIGN : lexer cs n-lexer ('/':cs) n = SLASH : lexer cs n-lexer ('{':cs) n = LSB : lexer cs n+newtype HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26 = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = GHC.Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn4 :: t4 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn4 x = unsafeCoerce# x+{-# INLINE happyIn4 #-}+happyOut4 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t4+happyOut4 x = unsafeCoerce# x+{-# INLINE happyOut4 #-}+happyIn5 :: t5 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn5 x = unsafeCoerce# x+{-# INLINE happyIn5 #-}+happyOut5 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t5+happyOut5 x = unsafeCoerce# x+{-# INLINE happyOut5 #-}+happyIn6 :: t6 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn6 x = unsafeCoerce# x+{-# INLINE happyIn6 #-}+happyOut6 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t6+happyOut6 x = unsafeCoerce# x+{-# INLINE happyOut6 #-}+happyIn7 :: t7 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn7 x = unsafeCoerce# x+{-# INLINE happyIn7 #-}+happyOut7 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t7+happyOut7 x = unsafeCoerce# x+{-# INLINE happyOut7 #-}+happyIn8 :: t8 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn8 x = unsafeCoerce# x+{-# INLINE happyIn8 #-}+happyOut8 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t8+happyOut8 x = unsafeCoerce# x+{-# INLINE happyOut8 #-}+happyIn9 :: t9 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn9 x = unsafeCoerce# x+{-# INLINE happyIn9 #-}+happyOut9 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t9+happyOut9 x = unsafeCoerce# x+{-# INLINE happyOut9 #-}+happyIn10 :: t10 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn10 x = unsafeCoerce# x+{-# INLINE happyIn10 #-}+happyOut10 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t10+happyOut10 x = unsafeCoerce# x+{-# INLINE happyOut10 #-}+happyIn11 :: t11 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn11 x = unsafeCoerce# x+{-# INLINE happyIn11 #-}+happyOut11 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t11+happyOut11 x = unsafeCoerce# x+{-# INLINE happyOut11 #-}+happyIn12 :: t12 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn12 x = unsafeCoerce# x+{-# INLINE happyIn12 #-}+happyOut12 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t12+happyOut12 x = unsafeCoerce# x+{-# INLINE happyOut12 #-}+happyIn13 :: t13 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn13 x = unsafeCoerce# x+{-# INLINE happyIn13 #-}+happyOut13 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t13+happyOut13 x = unsafeCoerce# x+{-# INLINE happyOut13 #-}+happyIn14 :: t14 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn14 x = unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t14+happyOut14 x = unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: t15 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn15 x = unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t15+happyOut15 x = unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: t16 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn16 x = unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t16+happyOut16 x = unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: t17 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn17 x = unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t17+happyOut17 x = unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: t18 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn18 x = unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t18+happyOut18 x = unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: t19 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn19 x = unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t19+happyOut19 x = unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: t20 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn20 x = unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t20+happyOut20 x = unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: t21 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn21 x = unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t21+happyOut21 x = unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: t22 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn22 x = unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t22+happyOut22 x = unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: t23 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn23 x = unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t23+happyOut23 x = unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: t24 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn24 x = unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t24+happyOut24 x = unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: t25 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn25 x = unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t25+happyOut25 x = unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: t26 -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyIn26 x = unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> t26+happyOut26 x = unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyInTok :: Token -> (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26)+happyInTok x = unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 t18 t19 t20 t21 t22 t23 t24 t25 t26) -> Token+happyOutTok x = unsafeCoerce# x+{-# INLINE happyOutTok #-}+++action_0 (28#) = happyShift action_12+action_0 (29#) = happyShift action_13+action_0 (30#) = happyShift action_14+action_0 (35#) = happyShift action_15+action_0 (42#) = happyShift action_16+action_0 (43#) = happyShift action_17+action_0 (44#) = happyShift action_18+action_0 (50#) = happyShift action_19+action_0 (56#) = happyShift action_20+action_0 (60#) = happyShift action_21+action_0 (61#) = happyShift action_22+action_0 (69#) = happyShift action_23+action_0 (70#) = happyShift action_24+action_0 (74#) = happyShift action_25+action_0 (76#) = happyShift action_26+action_0 (77#) = happyShift action_34+action_0 (81#) = happyShift action_27+action_0 (83#) = happyShift action_28+action_0 (85#) = happyShift action_29+action_0 (86#) = happyShift action_30+action_0 (87#) = happyShift action_31+action_0 (4#) = happyGoto action_32+action_0 (6#) = happyGoto action_2+action_0 (7#) = happyGoto action_33+action_0 (9#) = happyGoto action_4+action_0 (16#) = happyGoto action_5+action_0 (17#) = happyGoto action_6+action_0 (18#) = happyGoto action_7+action_0 (21#) = happyGoto action_8+action_0 (24#) = happyGoto action_9+action_0 (25#) = happyGoto action_10+action_0 (26#) = happyGoto action_11+action_0 x = happyTcHack x happyFail++action_1 (28#) = happyShift action_12+action_1 (29#) = happyShift action_13+action_1 (30#) = happyShift action_14+action_1 (35#) = happyShift action_15+action_1 (42#) = happyShift action_16+action_1 (43#) = happyShift action_17+action_1 (44#) = happyShift action_18+action_1 (50#) = happyShift action_19+action_1 (56#) = happyShift action_20+action_1 (60#) = happyShift action_21+action_1 (61#) = happyShift action_22+action_1 (69#) = happyShift action_23+action_1 (70#) = happyShift action_24+action_1 (74#) = happyShift action_25+action_1 (76#) = happyShift action_26+action_1 (81#) = happyShift action_27+action_1 (83#) = happyShift action_28+action_1 (85#) = happyShift action_29+action_1 (86#) = happyShift action_30+action_1 (87#) = happyShift action_31+action_1 (6#) = happyGoto action_2+action_1 (7#) = happyGoto action_3+action_1 (9#) = happyGoto action_4+action_1 (16#) = happyGoto action_5+action_1 (17#) = happyGoto action_6+action_1 (18#) = happyGoto action_7+action_1 (21#) = happyGoto action_8+action_1 (24#) = happyGoto action_9+action_1 (25#) = happyGoto action_10+action_1 (26#) = happyGoto action_11+action_1 x = happyTcHack x happyFail++action_2 x = happyTcHack x happyReduce_96++action_3 (41#) = happyShift action_36+action_3 (42#) = happyShift action_37+action_3 (43#) = happyShift action_38+action_3 (44#) = happyShift action_39+action_3 (45#) = happyShift action_40+action_3 (46#) = happyShift action_41+action_3 (47#) = happyShift action_42+action_3 (48#) = happyShift action_43+action_3 (49#) = happyShift action_44+action_3 (50#) = happyShift action_45+action_3 (51#) = happyShift action_46+action_3 (52#) = happyShift action_47+action_3 (53#) = happyShift action_48+action_3 (54#) = happyShift action_49+action_3 (55#) = happyShift action_50+action_3 (56#) = happyShift action_51+action_3 (57#) = happyShift action_52+action_3 (58#) = happyShift action_53+action_3 (59#) = happyShift action_54+action_3 x = happyTcHack x happyFail++action_4 (60#) = happyShift action_81+action_4 (61#) = happyShift action_82+action_4 (65#) = happyShift action_83+action_4 (12#) = happyGoto action_80+action_4 x = happyTcHack x happyReduce_53++action_5 x = happyTcHack x happyReduce_14++action_6 x = happyTcHack x happyReduce_13++action_7 (52#) = happyShift action_78+action_7 (72#) = happyShift action_79+action_7 x = happyTcHack x happyFail++action_8 x = happyTcHack x happyReduce_12++action_9 (33#) = happyShift action_76+action_9 (75#) = happyShift action_77+action_9 (22#) = happyGoto action_74+action_9 (23#) = happyGoto action_75+action_9 x = happyTcHack x happyReduce_80++action_10 x = happyTcHack x happyReduce_91++action_11 x = happyTcHack x happyReduce_93++action_12 (83#) = happyShift action_28+action_12 (6#) = happyGoto action_62+action_12 (10#) = happyGoto action_73+action_12 x = happyTcHack x happyFail++action_13 (83#) = happyShift action_28+action_13 (6#) = happyGoto action_62+action_13 (10#) = happyGoto action_72+action_13 x = happyTcHack x happyFail++action_14 (28#) = happyShift action_12+action_14 (29#) = happyShift action_13+action_14 (30#) = happyShift action_14+action_14 (35#) = happyShift action_15+action_14 (42#) = happyShift action_16+action_14 (43#) = happyShift action_17+action_14 (44#) = happyShift action_18+action_14 (50#) = happyShift action_19+action_14 (56#) = happyShift action_20+action_14 (60#) = happyShift action_21+action_14 (61#) = happyShift action_22+action_14 (69#) = happyShift action_23+action_14 (70#) = happyShift action_24+action_14 (74#) = happyShift action_25+action_14 (76#) = happyShift action_26+action_14 (81#) = happyShift action_27+action_14 (83#) = happyShift action_28+action_14 (85#) = happyShift action_29+action_14 (86#) = happyShift action_30+action_14 (87#) = happyShift action_31+action_14 (6#) = happyGoto action_2+action_14 (7#) = happyGoto action_71+action_14 (9#) = happyGoto action_4+action_14 (16#) = happyGoto action_5+action_14 (17#) = happyGoto action_6+action_14 (18#) = happyGoto action_7+action_14 (21#) = happyGoto action_8+action_14 (24#) = happyGoto action_9+action_14 (25#) = happyGoto action_10+action_14 (26#) = happyGoto action_11+action_14 x = happyTcHack x happyFail++action_15 (28#) = happyShift action_12+action_15 (29#) = happyShift action_13+action_15 (30#) = happyShift action_14+action_15 (35#) = happyShift action_15+action_15 (36#) = happyShift action_70+action_15 (42#) = happyShift action_16+action_15 (43#) = happyShift action_17+action_15 (44#) = happyShift action_18+action_15 (50#) = happyShift action_19+action_15 (56#) = happyShift action_20+action_15 (60#) = happyShift action_21+action_15 (61#) = happyShift action_22+action_15 (69#) = happyShift action_23+action_15 (70#) = happyShift action_24+action_15 (74#) = happyShift action_25+action_15 (76#) = happyShift action_26+action_15 (81#) = happyShift action_27+action_15 (83#) = happyShift action_28+action_15 (85#) = happyShift action_29+action_15 (86#) = happyShift action_30+action_15 (87#) = happyShift action_31+action_15 (6#) = happyGoto action_2+action_15 (7#) = happyGoto action_68+action_15 (8#) = happyGoto action_69+action_15 (9#) = happyGoto action_4+action_15 (16#) = happyGoto action_5+action_15 (17#) = happyGoto action_6+action_15 (18#) = happyGoto action_7+action_15 (21#) = happyGoto action_8+action_15 (24#) = happyGoto action_9+action_15 (25#) = happyGoto action_10+action_15 (26#) = happyGoto action_11+action_15 x = happyTcHack x happyFail++action_16 (28#) = happyShift action_12+action_16 (29#) = happyShift action_13+action_16 (30#) = happyShift action_14+action_16 (35#) = happyShift action_15+action_16 (42#) = happyShift action_16+action_16 (43#) = happyShift action_17+action_16 (44#) = happyShift action_18+action_16 (50#) = happyShift action_19+action_16 (56#) = happyShift action_20+action_16 (60#) = happyShift action_21+action_16 (61#) = happyShift action_22+action_16 (69#) = happyShift action_23+action_16 (70#) = happyShift action_24+action_16 (74#) = happyShift action_25+action_16 (76#) = happyShift action_26+action_16 (81#) = happyShift action_27+action_16 (83#) = happyShift action_28+action_16 (85#) = happyShift action_29+action_16 (86#) = happyShift action_30+action_16 (87#) = happyShift action_31+action_16 (6#) = happyGoto action_2+action_16 (7#) = happyGoto action_67+action_16 (9#) = happyGoto action_4+action_16 (16#) = happyGoto action_5+action_16 (17#) = happyGoto action_6+action_16 (18#) = happyGoto action_7+action_16 (21#) = happyGoto action_8+action_16 (24#) = happyGoto action_9+action_16 (25#) = happyGoto action_10+action_16 (26#) = happyGoto action_11+action_16 x = happyTcHack x happyFail++action_17 (28#) = happyShift action_12+action_17 (29#) = happyShift action_13+action_17 (30#) = happyShift action_14+action_17 (35#) = happyShift action_15+action_17 (42#) = happyShift action_16+action_17 (43#) = happyShift action_17+action_17 (44#) = happyShift action_18+action_17 (50#) = happyShift action_19+action_17 (56#) = happyShift action_20+action_17 (60#) = happyShift action_21+action_17 (61#) = happyShift action_22+action_17 (69#) = happyShift action_23+action_17 (70#) = happyShift action_24+action_17 (74#) = happyShift action_25+action_17 (76#) = happyShift action_26+action_17 (81#) = happyShift action_27+action_17 (83#) = happyShift action_28+action_17 (85#) = happyShift action_29+action_17 (86#) = happyShift action_30+action_17 (87#) = happyShift action_31+action_17 (6#) = happyGoto action_2+action_17 (7#) = happyGoto action_66+action_17 (9#) = happyGoto action_4+action_17 (16#) = happyGoto action_5+action_17 (17#) = happyGoto action_6+action_17 (18#) = happyGoto action_7+action_17 (21#) = happyGoto action_8+action_17 (24#) = happyGoto action_9+action_17 (25#) = happyGoto action_10+action_17 (26#) = happyGoto action_11+action_17 x = happyTcHack x happyFail++action_18 x = happyTcHack x happyReduce_94++action_19 (76#) = happyShift action_65+action_19 x = happyTcHack x happyFail++action_20 (28#) = happyShift action_12+action_20 (29#) = happyShift action_13+action_20 (30#) = happyShift action_14+action_20 (35#) = happyShift action_15+action_20 (42#) = happyShift action_16+action_20 (43#) = happyShift action_17+action_20 (44#) = happyShift action_18+action_20 (50#) = happyShift action_19+action_20 (56#) = happyShift action_20+action_20 (60#) = happyShift action_21+action_20 (61#) = happyShift action_22+action_20 (69#) = happyShift action_23+action_20 (70#) = happyShift action_24+action_20 (74#) = happyShift action_25+action_20 (76#) = happyShift action_26+action_20 (81#) = happyShift action_27+action_20 (83#) = happyShift action_28+action_20 (85#) = happyShift action_29+action_20 (86#) = happyShift action_30+action_20 (87#) = happyShift action_31+action_20 (6#) = happyGoto action_2+action_20 (7#) = happyGoto action_64+action_20 (9#) = happyGoto action_4+action_20 (16#) = happyGoto action_5+action_20 (17#) = happyGoto action_6+action_20 (18#) = happyGoto action_7+action_20 (21#) = happyGoto action_8+action_20 (24#) = happyGoto action_9+action_20 (25#) = happyGoto action_10+action_20 (26#) = happyGoto action_11+action_20 x = happyTcHack x happyFail++action_21 (83#) = happyShift action_28+action_21 (6#) = happyGoto action_62+action_21 (10#) = happyGoto action_63+action_21 x = happyTcHack x happyFail++action_22 (83#) = happyShift action_28+action_22 (6#) = happyGoto action_60+action_22 (11#) = happyGoto action_61+action_22 x = happyTcHack x happyFail++action_23 (35#) = happyShift action_59+action_23 x = happyTcHack x happyFail++action_24 (35#) = happyShift action_58+action_24 x = happyTcHack x happyFail++action_25 (35#) = happyShift action_15+action_25 (44#) = happyShift action_18+action_25 (76#) = happyShift action_26+action_25 (81#) = happyShift action_27+action_25 (83#) = happyShift action_28+action_25 (6#) = happyGoto action_2+action_25 (24#) = happyGoto action_57+action_25 (25#) = happyGoto action_10+action_25 (26#) = happyGoto action_11+action_25 x = happyTcHack x happyFail++action_26 (35#) = happyShift action_56+action_26 x = happyTcHack x happyReduce_95++action_27 x = happyTcHack x happyReduce_97++action_28 x = happyTcHack x happyReduce_7++action_29 x = happyTcHack x happyReduce_38++action_30 x = happyTcHack x happyReduce_39++action_31 x = happyTcHack x happyReduce_37++action_32 (88#) = happyAccept+action_32 x = happyTcHack x happyFail++action_33 (41#) = happyShift action_36+action_33 (42#) = happyShift action_37+action_33 (43#) = happyShift action_38+action_33 (44#) = happyShift action_39+action_33 (45#) = happyShift action_40+action_33 (46#) = happyShift action_41+action_33 (47#) = happyShift action_42+action_33 (48#) = happyShift action_43+action_33 (49#) = happyShift action_44+action_33 (50#) = happyShift action_45+action_33 (51#) = happyShift action_46+action_33 (52#) = happyShift action_47+action_33 (53#) = happyShift action_48+action_33 (54#) = happyShift action_49+action_33 (55#) = happyShift action_50+action_33 (56#) = happyShift action_51+action_33 (57#) = happyShift action_52+action_33 (58#) = happyShift action_53+action_33 (59#) = happyShift action_54+action_33 (84#) = happyShift action_55+action_33 x = happyTcHack x happyReduce_1++action_34 (78#) = happyShift action_35+action_34 x = happyTcHack x happyFail++action_35 (76#) = happyShift action_136+action_35 x = happyTcHack x happyFail++action_36 (28#) = happyShift action_12+action_36 (29#) = happyShift action_13+action_36 (30#) = happyShift action_14+action_36 (35#) = happyShift action_15+action_36 (42#) = happyShift action_16+action_36 (43#) = happyShift action_17+action_36 (44#) = happyShift action_18+action_36 (50#) = happyShift action_19+action_36 (56#) = happyShift action_20+action_36 (60#) = happyShift action_21+action_36 (61#) = happyShift action_22+action_36 (69#) = happyShift action_23+action_36 (70#) = happyShift action_24+action_36 (74#) = happyShift action_25+action_36 (76#) = happyShift action_26+action_36 (81#) = happyShift action_27+action_36 (83#) = happyShift action_28+action_36 (85#) = happyShift action_29+action_36 (86#) = happyShift action_30+action_36 (87#) = happyShift action_31+action_36 (6#) = happyGoto action_2+action_36 (7#) = happyGoto action_135+action_36 (9#) = happyGoto action_4+action_36 (16#) = happyGoto action_5+action_36 (17#) = happyGoto action_6+action_36 (18#) = happyGoto action_7+action_36 (21#) = happyGoto action_8+action_36 (24#) = happyGoto action_9+action_36 (25#) = happyGoto action_10+action_36 (26#) = happyGoto action_11+action_36 x = happyTcHack x happyFail++action_37 (28#) = happyShift action_12+action_37 (29#) = happyShift action_13+action_37 (30#) = happyShift action_14+action_37 (35#) = happyShift action_15+action_37 (42#) = happyShift action_16+action_37 (43#) = happyShift action_17+action_37 (44#) = happyShift action_18+action_37 (50#) = happyShift action_19+action_37 (56#) = happyShift action_20+action_37 (60#) = happyShift action_21+action_37 (61#) = happyShift action_22+action_37 (69#) = happyShift action_23+action_37 (70#) = happyShift action_24+action_37 (74#) = happyShift action_25+action_37 (76#) = happyShift action_26+action_37 (81#) = happyShift action_27+action_37 (83#) = happyShift action_28+action_37 (85#) = happyShift action_29+action_37 (86#) = happyShift action_30+action_37 (87#) = happyShift action_31+action_37 (6#) = happyGoto action_2+action_37 (7#) = happyGoto action_134+action_37 (9#) = happyGoto action_4+action_37 (16#) = happyGoto action_5+action_37 (17#) = happyGoto action_6+action_37 (18#) = happyGoto action_7+action_37 (21#) = happyGoto action_8+action_37 (24#) = happyGoto action_9+action_37 (25#) = happyGoto action_10+action_37 (26#) = happyGoto action_11+action_37 x = happyTcHack x happyFail++action_38 (28#) = happyShift action_12+action_38 (29#) = happyShift action_13+action_38 (30#) = happyShift action_14+action_38 (35#) = happyShift action_15+action_38 (42#) = happyShift action_16+action_38 (43#) = happyShift action_17+action_38 (44#) = happyShift action_18+action_38 (50#) = happyShift action_19+action_38 (56#) = happyShift action_20+action_38 (60#) = happyShift action_21+action_38 (61#) = happyShift action_22+action_38 (69#) = happyShift action_23+action_38 (70#) = happyShift action_24+action_38 (74#) = happyShift action_25+action_38 (76#) = happyShift action_26+action_38 (81#) = happyShift action_27+action_38 (83#) = happyShift action_28+action_38 (85#) = happyShift action_29+action_38 (86#) = happyShift action_30+action_38 (87#) = happyShift action_31+action_38 (6#) = happyGoto action_2+action_38 (7#) = happyGoto action_133+action_38 (9#) = happyGoto action_4+action_38 (16#) = happyGoto action_5+action_38 (17#) = happyGoto action_6+action_38 (18#) = happyGoto action_7+action_38 (21#) = happyGoto action_8+action_38 (24#) = happyGoto action_9+action_38 (25#) = happyGoto action_10+action_38 (26#) = happyGoto action_11+action_38 x = happyTcHack x happyFail++action_39 (28#) = happyShift action_12+action_39 (29#) = happyShift action_13+action_39 (30#) = happyShift action_14+action_39 (35#) = happyShift action_15+action_39 (42#) = happyShift action_16+action_39 (43#) = happyShift action_17+action_39 (44#) = happyShift action_18+action_39 (50#) = happyShift action_19+action_39 (56#) = happyShift action_20+action_39 (60#) = happyShift action_21+action_39 (61#) = happyShift action_22+action_39 (69#) = happyShift action_23+action_39 (70#) = happyShift action_24+action_39 (74#) = happyShift action_25+action_39 (76#) = happyShift action_26+action_39 (81#) = happyShift action_27+action_39 (83#) = happyShift action_28+action_39 (85#) = happyShift action_29+action_39 (86#) = happyShift action_30+action_39 (87#) = happyShift action_31+action_39 (6#) = happyGoto action_2+action_39 (7#) = happyGoto action_132+action_39 (9#) = happyGoto action_4+action_39 (16#) = happyGoto action_5+action_39 (17#) = happyGoto action_6+action_39 (18#) = happyGoto action_7+action_39 (21#) = happyGoto action_8+action_39 (24#) = happyGoto action_9+action_39 (25#) = happyGoto action_10+action_39 (26#) = happyGoto action_11+action_39 x = happyTcHack x happyFail++action_40 (28#) = happyShift action_12+action_40 (29#) = happyShift action_13+action_40 (30#) = happyShift action_14+action_40 (35#) = happyShift action_15+action_40 (42#) = happyShift action_16+action_40 (43#) = happyShift action_17+action_40 (44#) = happyShift action_18+action_40 (50#) = happyShift action_19+action_40 (56#) = happyShift action_20+action_40 (60#) = happyShift action_21+action_40 (61#) = happyShift action_22+action_40 (69#) = happyShift action_23+action_40 (70#) = happyShift action_24+action_40 (74#) = happyShift action_25+action_40 (76#) = happyShift action_26+action_40 (81#) = happyShift action_27+action_40 (83#) = happyShift action_28+action_40 (85#) = happyShift action_29+action_40 (86#) = happyShift action_30+action_40 (87#) = happyShift action_31+action_40 (6#) = happyGoto action_2+action_40 (7#) = happyGoto action_131+action_40 (9#) = happyGoto action_4+action_40 (16#) = happyGoto action_5+action_40 (17#) = happyGoto action_6+action_40 (18#) = happyGoto action_7+action_40 (21#) = happyGoto action_8+action_40 (24#) = happyGoto action_9+action_40 (25#) = happyGoto action_10+action_40 (26#) = happyGoto action_11+action_40 x = happyTcHack x happyFail++action_41 (28#) = happyShift action_12+action_41 (29#) = happyShift action_13+action_41 (30#) = happyShift action_14+action_41 (35#) = happyShift action_15+action_41 (42#) = happyShift action_16+action_41 (43#) = happyShift action_17+action_41 (44#) = happyShift action_18+action_41 (50#) = happyShift action_19+action_41 (56#) = happyShift action_20+action_41 (60#) = happyShift action_21+action_41 (61#) = happyShift action_22+action_41 (69#) = happyShift action_23+action_41 (70#) = happyShift action_24+action_41 (74#) = happyShift action_25+action_41 (76#) = happyShift action_26+action_41 (81#) = happyShift action_27+action_41 (83#) = happyShift action_28+action_41 (85#) = happyShift action_29+action_41 (86#) = happyShift action_30+action_41 (87#) = happyShift action_31+action_41 (6#) = happyGoto action_2+action_41 (7#) = happyGoto action_130+action_41 (9#) = happyGoto action_4+action_41 (16#) = happyGoto action_5+action_41 (17#) = happyGoto action_6+action_41 (18#) = happyGoto action_7+action_41 (21#) = happyGoto action_8+action_41 (24#) = happyGoto action_9+action_41 (25#) = happyGoto action_10+action_41 (26#) = happyGoto action_11+action_41 x = happyTcHack x happyFail++action_42 (28#) = happyShift action_12+action_42 (29#) = happyShift action_13+action_42 (30#) = happyShift action_14+action_42 (35#) = happyShift action_15+action_42 (42#) = happyShift action_16+action_42 (43#) = happyShift action_17+action_42 (44#) = happyShift action_18+action_42 (50#) = happyShift action_19+action_42 (56#) = happyShift action_20+action_42 (60#) = happyShift action_21+action_42 (61#) = happyShift action_22+action_42 (69#) = happyShift action_23+action_42 (70#) = happyShift action_24+action_42 (74#) = happyShift action_25+action_42 (76#) = happyShift action_26+action_42 (81#) = happyShift action_27+action_42 (83#) = happyShift action_28+action_42 (85#) = happyShift action_29+action_42 (86#) = happyShift action_30+action_42 (87#) = happyShift action_31+action_42 (6#) = happyGoto action_2+action_42 (7#) = happyGoto action_129+action_42 (9#) = happyGoto action_4+action_42 (16#) = happyGoto action_5+action_42 (17#) = happyGoto action_6+action_42 (18#) = happyGoto action_7+action_42 (21#) = happyGoto action_8+action_42 (24#) = happyGoto action_9+action_42 (25#) = happyGoto action_10+action_42 (26#) = happyGoto action_11+action_42 x = happyTcHack x happyFail++action_43 (28#) = happyShift action_12+action_43 (29#) = happyShift action_13+action_43 (30#) = happyShift action_14+action_43 (35#) = happyShift action_15+action_43 (42#) = happyShift action_16+action_43 (43#) = happyShift action_17+action_43 (44#) = happyShift action_18+action_43 (50#) = happyShift action_19+action_43 (56#) = happyShift action_20+action_43 (60#) = happyShift action_21+action_43 (61#) = happyShift action_22+action_43 (69#) = happyShift action_23+action_43 (70#) = happyShift action_24+action_43 (74#) = happyShift action_25+action_43 (76#) = happyShift action_26+action_43 (81#) = happyShift action_27+action_43 (83#) = happyShift action_28+action_43 (85#) = happyShift action_29+action_43 (86#) = happyShift action_30+action_43 (87#) = happyShift action_31+action_43 (6#) = happyGoto action_2+action_43 (7#) = happyGoto action_128+action_43 (9#) = happyGoto action_4+action_43 (16#) = happyGoto action_5+action_43 (17#) = happyGoto action_6+action_43 (18#) = happyGoto action_7+action_43 (21#) = happyGoto action_8+action_43 (24#) = happyGoto action_9+action_43 (25#) = happyGoto action_10+action_43 (26#) = happyGoto action_11+action_43 x = happyTcHack x happyFail++action_44 (28#) = happyShift action_12+action_44 (29#) = happyShift action_13+action_44 (30#) = happyShift action_14+action_44 (35#) = happyShift action_15+action_44 (42#) = happyShift action_16+action_44 (43#) = happyShift action_17+action_44 (44#) = happyShift action_18+action_44 (50#) = happyShift action_19+action_44 (56#) = happyShift action_20+action_44 (60#) = happyShift action_21+action_44 (61#) = happyShift action_22+action_44 (69#) = happyShift action_23+action_44 (70#) = happyShift action_24+action_44 (74#) = happyShift action_25+action_44 (76#) = happyShift action_26+action_44 (81#) = happyShift action_27+action_44 (83#) = happyShift action_28+action_44 (85#) = happyShift action_29+action_44 (86#) = happyShift action_30+action_44 (87#) = happyShift action_31+action_44 (6#) = happyGoto action_2+action_44 (7#) = happyGoto action_127+action_44 (9#) = happyGoto action_4+action_44 (16#) = happyGoto action_5+action_44 (17#) = happyGoto action_6+action_44 (18#) = happyGoto action_7+action_44 (21#) = happyGoto action_8+action_44 (24#) = happyGoto action_9+action_44 (25#) = happyGoto action_10+action_44 (26#) = happyGoto action_11+action_44 x = happyTcHack x happyFail++action_45 (28#) = happyShift action_12+action_45 (29#) = happyShift action_13+action_45 (30#) = happyShift action_14+action_45 (35#) = happyShift action_15+action_45 (42#) = happyShift action_16+action_45 (43#) = happyShift action_17+action_45 (44#) = happyShift action_18+action_45 (50#) = happyShift action_19+action_45 (56#) = happyShift action_20+action_45 (60#) = happyShift action_21+action_45 (61#) = happyShift action_22+action_45 (69#) = happyShift action_23+action_45 (70#) = happyShift action_24+action_45 (74#) = happyShift action_25+action_45 (76#) = happyShift action_26+action_45 (81#) = happyShift action_27+action_45 (83#) = happyShift action_28+action_45 (85#) = happyShift action_29+action_45 (86#) = happyShift action_30+action_45 (87#) = happyShift action_31+action_45 (6#) = happyGoto action_2+action_45 (7#) = happyGoto action_126+action_45 (9#) = happyGoto action_4+action_45 (16#) = happyGoto action_5+action_45 (17#) = happyGoto action_6+action_45 (18#) = happyGoto action_7+action_45 (21#) = happyGoto action_8+action_45 (24#) = happyGoto action_9+action_45 (25#) = happyGoto action_10+action_45 (26#) = happyGoto action_11+action_45 x = happyTcHack x happyFail++action_46 (28#) = happyShift action_12+action_46 (29#) = happyShift action_13+action_46 (30#) = happyShift action_14+action_46 (35#) = happyShift action_15+action_46 (42#) = happyShift action_16+action_46 (43#) = happyShift action_17+action_46 (44#) = happyShift action_18+action_46 (50#) = happyShift action_19+action_46 (56#) = happyShift action_20+action_46 (60#) = happyShift action_21+action_46 (61#) = happyShift action_22+action_46 (69#) = happyShift action_23+action_46 (70#) = happyShift action_24+action_46 (74#) = happyShift action_25+action_46 (76#) = happyShift action_26+action_46 (81#) = happyShift action_27+action_46 (83#) = happyShift action_28+action_46 (85#) = happyShift action_29+action_46 (86#) = happyShift action_30+action_46 (87#) = happyShift action_31+action_46 (6#) = happyGoto action_2+action_46 (7#) = happyGoto action_125+action_46 (9#) = happyGoto action_4+action_46 (16#) = happyGoto action_5+action_46 (17#) = happyGoto action_6+action_46 (18#) = happyGoto action_7+action_46 (21#) = happyGoto action_8+action_46 (24#) = happyGoto action_9+action_46 (25#) = happyGoto action_10+action_46 (26#) = happyGoto action_11+action_46 x = happyTcHack x happyFail++action_47 (28#) = happyShift action_12+action_47 (29#) = happyShift action_13+action_47 (30#) = happyShift action_14+action_47 (35#) = happyShift action_15+action_47 (42#) = happyShift action_16+action_47 (43#) = happyShift action_17+action_47 (44#) = happyShift action_18+action_47 (50#) = happyShift action_19+action_47 (56#) = happyShift action_20+action_47 (60#) = happyShift action_21+action_47 (61#) = happyShift action_22+action_47 (69#) = happyShift action_23+action_47 (70#) = happyShift action_24+action_47 (74#) = happyShift action_25+action_47 (76#) = happyShift action_26+action_47 (81#) = happyShift action_27+action_47 (83#) = happyShift action_28+action_47 (85#) = happyShift action_29+action_47 (86#) = happyShift action_30+action_47 (87#) = happyShift action_31+action_47 (6#) = happyGoto action_2+action_47 (7#) = happyGoto action_124+action_47 (9#) = happyGoto action_4+action_47 (16#) = happyGoto action_5+action_47 (17#) = happyGoto action_6+action_47 (18#) = happyGoto action_7+action_47 (21#) = happyGoto action_8+action_47 (24#) = happyGoto action_9+action_47 (25#) = happyGoto action_10+action_47 (26#) = happyGoto action_11+action_47 x = happyTcHack x happyFail++action_48 (28#) = happyShift action_12+action_48 (29#) = happyShift action_13+action_48 (30#) = happyShift action_14+action_48 (35#) = happyShift action_15+action_48 (42#) = happyShift action_16+action_48 (43#) = happyShift action_17+action_48 (44#) = happyShift action_18+action_48 (50#) = happyShift action_19+action_48 (56#) = happyShift action_20+action_48 (60#) = happyShift action_21+action_48 (61#) = happyShift action_22+action_48 (69#) = happyShift action_23+action_48 (70#) = happyShift action_24+action_48 (74#) = happyShift action_25+action_48 (76#) = happyShift action_26+action_48 (81#) = happyShift action_27+action_48 (83#) = happyShift action_28+action_48 (85#) = happyShift action_29+action_48 (86#) = happyShift action_30+action_48 (87#) = happyShift action_31+action_48 (6#) = happyGoto action_2+action_48 (7#) = happyGoto action_123+action_48 (9#) = happyGoto action_4+action_48 (16#) = happyGoto action_5+action_48 (17#) = happyGoto action_6+action_48 (18#) = happyGoto action_7+action_48 (21#) = happyGoto action_8+action_48 (24#) = happyGoto action_9+action_48 (25#) = happyGoto action_10+action_48 (26#) = happyGoto action_11+action_48 x = happyTcHack x happyFail++action_49 (28#) = happyShift action_12+action_49 (29#) = happyShift action_13+action_49 (30#) = happyShift action_14+action_49 (35#) = happyShift action_15+action_49 (42#) = happyShift action_16+action_49 (43#) = happyShift action_17+action_49 (44#) = happyShift action_18+action_49 (50#) = happyShift action_19+action_49 (56#) = happyShift action_20+action_49 (60#) = happyShift action_21+action_49 (61#) = happyShift action_22+action_49 (69#) = happyShift action_23+action_49 (70#) = happyShift action_24+action_49 (74#) = happyShift action_25+action_49 (76#) = happyShift action_26+action_49 (81#) = happyShift action_27+action_49 (83#) = happyShift action_28+action_49 (85#) = happyShift action_29+action_49 (86#) = happyShift action_30+action_49 (87#) = happyShift action_31+action_49 (6#) = happyGoto action_2+action_49 (7#) = happyGoto action_122+action_49 (9#) = happyGoto action_4+action_49 (16#) = happyGoto action_5+action_49 (17#) = happyGoto action_6+action_49 (18#) = happyGoto action_7+action_49 (21#) = happyGoto action_8+action_49 (24#) = happyGoto action_9+action_49 (25#) = happyGoto action_10+action_49 (26#) = happyGoto action_11+action_49 x = happyTcHack x happyFail++action_50 (28#) = happyShift action_12+action_50 (29#) = happyShift action_13+action_50 (30#) = happyShift action_14+action_50 (35#) = happyShift action_15+action_50 (42#) = happyShift action_16+action_50 (43#) = happyShift action_17+action_50 (44#) = happyShift action_18+action_50 (50#) = happyShift action_19+action_50 (56#) = happyShift action_20+action_50 (60#) = happyShift action_21+action_50 (61#) = happyShift action_22+action_50 (69#) = happyShift action_23+action_50 (70#) = happyShift action_24+action_50 (74#) = happyShift action_25+action_50 (76#) = happyShift action_26+action_50 (81#) = happyShift action_27+action_50 (83#) = happyShift action_28+action_50 (85#) = happyShift action_29+action_50 (86#) = happyShift action_30+action_50 (87#) = happyShift action_31+action_50 (6#) = happyGoto action_2+action_50 (7#) = happyGoto action_121+action_50 (9#) = happyGoto action_4+action_50 (16#) = happyGoto action_5+action_50 (17#) = happyGoto action_6+action_50 (18#) = happyGoto action_7+action_50 (21#) = happyGoto action_8+action_50 (24#) = happyGoto action_9+action_50 (25#) = happyGoto action_10+action_50 (26#) = happyGoto action_11+action_50 x = happyTcHack x happyFail++action_51 (28#) = happyShift action_12+action_51 (29#) = happyShift action_13+action_51 (30#) = happyShift action_14+action_51 (35#) = happyShift action_15+action_51 (42#) = happyShift action_16+action_51 (43#) = happyShift action_17+action_51 (44#) = happyShift action_18+action_51 (50#) = happyShift action_19+action_51 (56#) = happyShift action_20+action_51 (60#) = happyShift action_21+action_51 (61#) = happyShift action_22+action_51 (69#) = happyShift action_23+action_51 (70#) = happyShift action_24+action_51 (74#) = happyShift action_25+action_51 (76#) = happyShift action_26+action_51 (81#) = happyShift action_27+action_51 (83#) = happyShift action_28+action_51 (85#) = happyShift action_29+action_51 (86#) = happyShift action_30+action_51 (87#) = happyShift action_31+action_51 (6#) = happyGoto action_2+action_51 (7#) = happyGoto action_120+action_51 (9#) = happyGoto action_4+action_51 (16#) = happyGoto action_5+action_51 (17#) = happyGoto action_6+action_51 (18#) = happyGoto action_7+action_51 (21#) = happyGoto action_8+action_51 (24#) = happyGoto action_9+action_51 (25#) = happyGoto action_10+action_51 (26#) = happyGoto action_11+action_51 x = happyTcHack x happyFail++action_52 (28#) = happyShift action_12+action_52 (29#) = happyShift action_13+action_52 (30#) = happyShift action_14+action_52 (35#) = happyShift action_15+action_52 (42#) = happyShift action_16+action_52 (43#) = happyShift action_17+action_52 (44#) = happyShift action_18+action_52 (50#) = happyShift action_19+action_52 (56#) = happyShift action_20+action_52 (60#) = happyShift action_21+action_52 (61#) = happyShift action_22+action_52 (69#) = happyShift action_23+action_52 (70#) = happyShift action_24+action_52 (74#) = happyShift action_25+action_52 (76#) = happyShift action_26+action_52 (81#) = happyShift action_27+action_52 (83#) = happyShift action_28+action_52 (85#) = happyShift action_29+action_52 (86#) = happyShift action_30+action_52 (87#) = happyShift action_31+action_52 (6#) = happyGoto action_2+action_52 (7#) = happyGoto action_119+action_52 (9#) = happyGoto action_4+action_52 (16#) = happyGoto action_5+action_52 (17#) = happyGoto action_6+action_52 (18#) = happyGoto action_7+action_52 (21#) = happyGoto action_8+action_52 (24#) = happyGoto action_9+action_52 (25#) = happyGoto action_10+action_52 (26#) = happyGoto action_11+action_52 x = happyTcHack x happyFail++action_53 (28#) = happyShift action_12+action_53 (29#) = happyShift action_13+action_53 (30#) = happyShift action_14+action_53 (35#) = happyShift action_15+action_53 (42#) = happyShift action_16+action_53 (43#) = happyShift action_17+action_53 (44#) = happyShift action_18+action_53 (50#) = happyShift action_19+action_53 (56#) = happyShift action_20+action_53 (60#) = happyShift action_21+action_53 (61#) = happyShift action_22+action_53 (69#) = happyShift action_23+action_53 (70#) = happyShift action_24+action_53 (74#) = happyShift action_25+action_53 (76#) = happyShift action_26+action_53 (81#) = happyShift action_27+action_53 (83#) = happyShift action_28+action_53 (85#) = happyShift action_29+action_53 (86#) = happyShift action_30+action_53 (87#) = happyShift action_31+action_53 (6#) = happyGoto action_2+action_53 (7#) = happyGoto action_118+action_53 (9#) = happyGoto action_4+action_53 (16#) = happyGoto action_5+action_53 (17#) = happyGoto action_6+action_53 (18#) = happyGoto action_7+action_53 (21#) = happyGoto action_8+action_53 (24#) = happyGoto action_9+action_53 (25#) = happyGoto action_10+action_53 (26#) = happyGoto action_11+action_53 x = happyTcHack x happyFail++action_54 (28#) = happyShift action_12+action_54 (29#) = happyShift action_13+action_54 (30#) = happyShift action_14+action_54 (35#) = happyShift action_15+action_54 (42#) = happyShift action_16+action_54 (43#) = happyShift action_17+action_54 (44#) = happyShift action_18+action_54 (50#) = happyShift action_19+action_54 (56#) = happyShift action_20+action_54 (60#) = happyShift action_21+action_54 (61#) = happyShift action_22+action_54 (69#) = happyShift action_23+action_54 (70#) = happyShift action_24+action_54 (74#) = happyShift action_25+action_54 (76#) = happyShift action_26+action_54 (81#) = happyShift action_27+action_54 (83#) = happyShift action_28+action_54 (85#) = happyShift action_29+action_54 (86#) = happyShift action_30+action_54 (87#) = happyShift action_31+action_54 (6#) = happyGoto action_2+action_54 (7#) = happyGoto action_117+action_54 (9#) = happyGoto action_4+action_54 (16#) = happyGoto action_5+action_54 (17#) = happyGoto action_6+action_54 (18#) = happyGoto action_7+action_54 (21#) = happyGoto action_8+action_54 (24#) = happyGoto action_9+action_54 (25#) = happyGoto action_10+action_54 (26#) = happyGoto action_11+action_54 x = happyTcHack x happyFail++action_55 x = happyTcHack x happyReduce_2++action_56 (28#) = happyShift action_12+action_56 (29#) = happyShift action_13+action_56 (30#) = happyShift action_14+action_56 (35#) = happyShift action_15+action_56 (36#) = happyShift action_116+action_56 (42#) = happyShift action_16+action_56 (43#) = happyShift action_17+action_56 (44#) = happyShift action_18+action_56 (50#) = happyShift action_19+action_56 (56#) = happyShift action_20+action_56 (60#) = happyShift action_21+action_56 (61#) = happyShift action_22+action_56 (69#) = happyShift action_23+action_56 (70#) = happyShift action_24+action_56 (74#) = happyShift action_25+action_56 (76#) = happyShift action_26+action_56 (81#) = happyShift action_27+action_56 (83#) = happyShift action_28+action_56 (85#) = happyShift action_29+action_56 (86#) = happyShift action_30+action_56 (87#) = happyShift action_31+action_56 (6#) = happyGoto action_2+action_56 (7#) = happyGoto action_68+action_56 (8#) = happyGoto action_115+action_56 (9#) = happyGoto action_4+action_56 (16#) = happyGoto action_5+action_56 (17#) = happyGoto action_6+action_56 (18#) = happyGoto action_7+action_56 (21#) = happyGoto action_8+action_56 (24#) = happyGoto action_9+action_56 (25#) = happyGoto action_10+action_56 (26#) = happyGoto action_11+action_56 x = happyTcHack x happyFail++action_57 (33#) = happyShift action_76+action_57 (75#) = happyShift action_77+action_57 (22#) = happyGoto action_114+action_57 (23#) = happyGoto action_75+action_57 x = happyTcHack x happyReduce_81++action_58 (76#) = happyShift action_113+action_58 x = happyTcHack x happyFail++action_59 (76#) = happyShift action_112+action_59 x = happyTcHack x happyFail++action_60 (64#) = happyShift action_111+action_60 x = happyTcHack x happyFail++action_61 (63#) = happyShift action_110+action_61 x = happyTcHack x happyReduce_43++action_62 (62#) = happyShift action_109+action_62 x = happyTcHack x happyFail++action_63 (63#) = happyShift action_101+action_63 x = happyTcHack x happyReduce_42++action_64 x = happyTcHack x happyReduce_36++action_65 (76#) = happyShift action_108+action_65 (20#) = happyGoto action_107+action_65 x = happyTcHack x happyReduce_66++action_66 x = happyTcHack x happyReduce_35++action_67 x = happyTcHack x happyReduce_34++action_68 (41#) = happyShift action_36+action_68 (42#) = happyShift action_37+action_68 (43#) = happyShift action_38+action_68 (44#) = happyShift action_39+action_68 (45#) = happyShift action_40+action_68 (46#) = happyShift action_41+action_68 (47#) = happyShift action_42+action_68 (48#) = happyShift action_43+action_68 (49#) = happyShift action_44+action_68 (50#) = happyShift action_45+action_68 (51#) = happyShift action_46+action_68 (52#) = happyShift action_47+action_68 (53#) = happyShift action_48+action_68 (54#) = happyShift action_49+action_68 (55#) = happyShift action_50+action_68 (56#) = happyShift action_51+action_68 (57#) = happyShift action_52+action_68 (58#) = happyShift action_53+action_68 (59#) = happyShift action_54+action_68 x = happyTcHack x happyReduce_40++action_69 (36#) = happyShift action_105+action_69 (63#) = happyShift action_106+action_69 x = happyTcHack x happyFail++action_70 x = happyTcHack x happyReduce_99++action_71 (31#) = happyShift action_104+action_71 (41#) = happyShift action_36+action_71 (42#) = happyShift action_37+action_71 (43#) = happyShift action_38+action_71 (44#) = happyShift action_39+action_71 (45#) = happyShift action_40+action_71 (46#) = happyShift action_41+action_71 (47#) = happyShift action_42+action_71 (48#) = happyShift action_43+action_71 (49#) = happyShift action_44+action_71 (50#) = happyShift action_45+action_71 (51#) = happyShift action_46+action_71 (52#) = happyShift action_47+action_71 (53#) = happyShift action_48+action_71 (54#) = happyShift action_49+action_71 (55#) = happyShift action_50+action_71 (56#) = happyShift action_51+action_71 (57#) = happyShift action_52+action_71 (58#) = happyShift action_53+action_71 (59#) = happyShift action_54+action_71 x = happyTcHack x happyFail++action_72 (63#) = happyShift action_101+action_72 (73#) = happyShift action_103+action_72 x = happyTcHack x happyFail++action_73 (63#) = happyShift action_101+action_73 (73#) = happyShift action_102+action_73 x = happyTcHack x happyFail++action_74 (75#) = happyShift action_77+action_74 (23#) = happyGoto action_100+action_74 x = happyTcHack x happyReduce_82++action_75 x = happyTcHack x happyReduce_84++action_76 (28#) = happyShift action_12+action_76 (29#) = happyShift action_13+action_76 (30#) = happyShift action_14+action_76 (35#) = happyShift action_15+action_76 (42#) = happyShift action_16+action_76 (43#) = happyShift action_17+action_76 (44#) = happyShift action_18+action_76 (50#) = happyShift action_19+action_76 (56#) = happyShift action_20+action_76 (60#) = happyShift action_21+action_76 (61#) = happyShift action_22+action_76 (69#) = happyShift action_23+action_76 (70#) = happyShift action_24+action_76 (74#) = happyShift action_25+action_76 (76#) = happyShift action_26+action_76 (81#) = happyShift action_27+action_76 (83#) = happyShift action_28+action_76 (85#) = happyShift action_29+action_76 (86#) = happyShift action_30+action_76 (87#) = happyShift action_31+action_76 (6#) = happyGoto action_2+action_76 (7#) = happyGoto action_99+action_76 (9#) = happyGoto action_4+action_76 (16#) = happyGoto action_5+action_76 (17#) = happyGoto action_6+action_76 (18#) = happyGoto action_7+action_76 (21#) = happyGoto action_8+action_76 (24#) = happyGoto action_9+action_76 (25#) = happyGoto action_10+action_76 (26#) = happyGoto action_11+action_76 x = happyTcHack x happyFail++action_77 (35#) = happyShift action_15+action_77 (44#) = happyShift action_18+action_77 (74#) = happyShift action_96+action_77 (75#) = happyShift action_97+action_77 (76#) = happyShift action_26+action_77 (80#) = happyShift action_98+action_77 (81#) = happyShift action_27+action_77 (83#) = happyShift action_28+action_77 (6#) = happyGoto action_2+action_77 (24#) = happyGoto action_95+action_77 (25#) = happyGoto action_10+action_77 (26#) = happyGoto action_11+action_77 x = happyTcHack x happyFail++action_78 (37#) = happyShift action_91+action_78 (50#) = happyShift action_19+action_78 (71#) = happyShift action_92+action_78 (84#) = happyShift action_93+action_78 (87#) = happyShift action_94+action_78 (17#) = happyGoto action_89+action_78 (18#) = happyGoto action_7+action_78 (19#) = happyGoto action_90+action_78 x = happyTcHack x happyFail++action_79 x = happyTcHack x happyReduce_65++action_80 (66#) = happyShift action_88+action_80 (13#) = happyGoto action_87+action_80 x = happyTcHack x happyReduce_55++action_81 (83#) = happyShift action_28+action_81 (6#) = happyGoto action_62+action_81 (10#) = happyGoto action_86+action_81 x = happyTcHack x happyFail++action_82 (83#) = happyShift action_28+action_82 (6#) = happyGoto action_60+action_82 (11#) = happyGoto action_85+action_82 x = happyTcHack x happyFail++action_83 (28#) = happyShift action_12+action_83 (29#) = happyShift action_13+action_83 (30#) = happyShift action_14+action_83 (35#) = happyShift action_15+action_83 (42#) = happyShift action_16+action_83 (43#) = happyShift action_17+action_83 (44#) = happyShift action_18+action_83 (50#) = happyShift action_19+action_83 (56#) = happyShift action_20+action_83 (60#) = happyShift action_21+action_83 (61#) = happyShift action_22+action_83 (69#) = happyShift action_23+action_83 (70#) = happyShift action_24+action_83 (74#) = happyShift action_25+action_83 (76#) = happyShift action_26+action_83 (81#) = happyShift action_27+action_83 (83#) = happyShift action_28+action_83 (85#) = happyShift action_29+action_83 (86#) = happyShift action_30+action_83 (87#) = happyShift action_31+action_83 (6#) = happyGoto action_2+action_83 (7#) = happyGoto action_84+action_83 (9#) = happyGoto action_4+action_83 (16#) = happyGoto action_5+action_83 (17#) = happyGoto action_6+action_83 (18#) = happyGoto action_7+action_83 (21#) = happyGoto action_8+action_83 (24#) = happyGoto action_9+action_83 (25#) = happyGoto action_10+action_83 (26#) = happyGoto action_11+action_83 x = happyTcHack x happyFail++action_84 (41#) = happyShift action_36+action_84 (42#) = happyShift action_37+action_84 (43#) = happyShift action_38+action_84 (44#) = happyShift action_39+action_84 (45#) = happyShift action_40+action_84 (46#) = happyShift action_41+action_84 (47#) = happyShift action_42+action_84 (48#) = happyShift action_43+action_84 (49#) = happyShift action_44+action_84 (50#) = happyShift action_45+action_84 (51#) = happyShift action_46+action_84 (52#) = happyShift action_47+action_84 (53#) = happyShift action_48+action_84 (54#) = happyShift action_49+action_84 (55#) = happyShift action_50+action_84 (56#) = happyShift action_51+action_84 (57#) = happyShift action_52+action_84 (58#) = happyShift action_53+action_84 (59#) = happyShift action_54+action_84 x = happyTcHack x happyReduce_52++action_85 (63#) = happyShift action_110+action_85 x = happyTcHack x happyReduce_45++action_86 (63#) = happyShift action_101+action_86 x = happyTcHack x happyReduce_44++action_87 (27#) = happyShift action_164+action_87 x = happyTcHack x happyFail++action_88 (28#) = happyShift action_12+action_88 (29#) = happyShift action_13+action_88 (30#) = happyShift action_14+action_88 (35#) = happyShift action_15+action_88 (42#) = happyShift action_16+action_88 (43#) = happyShift action_17+action_88 (44#) = happyShift action_18+action_88 (50#) = happyShift action_19+action_88 (56#) = happyShift action_20+action_88 (60#) = happyShift action_21+action_88 (61#) = happyShift action_22+action_88 (69#) = happyShift action_23+action_88 (70#) = happyShift action_24+action_88 (74#) = happyShift action_25+action_88 (76#) = happyShift action_26+action_88 (81#) = happyShift action_27+action_88 (83#) = happyShift action_28+action_88 (85#) = happyShift action_29+action_88 (86#) = happyShift action_30+action_88 (87#) = happyShift action_31+action_88 (6#) = happyGoto action_2+action_88 (7#) = happyGoto action_162+action_88 (9#) = happyGoto action_4+action_88 (14#) = happyGoto action_163+action_88 (16#) = happyGoto action_5+action_88 (17#) = happyGoto action_6+action_88 (18#) = happyGoto action_7+action_88 (21#) = happyGoto action_8+action_88 (24#) = happyGoto action_9+action_88 (25#) = happyGoto action_10+action_88 (26#) = happyGoto action_11+action_88 x = happyTcHack x happyFail++action_89 x = happyTcHack x happyReduce_71++action_90 (37#) = happyShift action_158+action_90 (50#) = happyShift action_19+action_90 (71#) = happyShift action_159+action_90 (84#) = happyShift action_160+action_90 (87#) = happyShift action_161+action_90 (17#) = happyGoto action_157+action_90 (18#) = happyGoto action_7+action_90 x = happyTcHack x happyFail++action_91 (28#) = happyShift action_12+action_91 (29#) = happyShift action_13+action_91 (30#) = happyShift action_14+action_91 (35#) = happyShift action_15+action_91 (42#) = happyShift action_16+action_91 (43#) = happyShift action_17+action_91 (44#) = happyShift action_18+action_91 (50#) = happyShift action_19+action_91 (56#) = happyShift action_20+action_91 (60#) = happyShift action_21+action_91 (61#) = happyShift action_22+action_91 (69#) = happyShift action_23+action_91 (70#) = happyShift action_24+action_91 (74#) = happyShift action_25+action_91 (76#) = happyShift action_26+action_91 (81#) = happyShift action_27+action_91 (83#) = happyShift action_28+action_91 (85#) = happyShift action_29+action_91 (86#) = happyShift action_30+action_91 (87#) = happyShift action_31+action_91 (6#) = happyGoto action_2+action_91 (7#) = happyGoto action_68+action_91 (8#) = happyGoto action_156+action_91 (9#) = happyGoto action_4+action_91 (16#) = happyGoto action_5+action_91 (17#) = happyGoto action_6+action_91 (18#) = happyGoto action_7+action_91 (21#) = happyGoto action_8+action_91 (24#) = happyGoto action_9+action_91 (25#) = happyGoto action_10+action_91 (26#) = happyGoto action_11+action_91 x = happyTcHack x happyFail++action_92 (76#) = happyShift action_155+action_92 x = happyTcHack x happyFail++action_93 x = happyTcHack x happyReduce_70++action_94 x = happyTcHack x happyReduce_69++action_95 (33#) = happyShift action_76+action_95 x = happyTcHack x happyReduce_86++action_96 (35#) = happyShift action_15+action_96 (44#) = happyShift action_18+action_96 (76#) = happyShift action_26+action_96 (81#) = happyShift action_27+action_96 (83#) = happyShift action_28+action_96 (6#) = happyGoto action_2+action_96 (24#) = happyGoto action_154+action_96 (25#) = happyGoto action_10+action_96 (26#) = happyGoto action_11+action_96 x = happyTcHack x happyFail++action_97 (35#) = happyShift action_15+action_97 (44#) = happyShift action_18+action_97 (74#) = happyShift action_153+action_97 (76#) = happyShift action_26+action_97 (81#) = happyShift action_27+action_97 (83#) = happyShift action_28+action_97 (6#) = happyGoto action_2+action_97 (24#) = happyGoto action_152+action_97 (25#) = happyGoto action_10+action_97 (26#) = happyGoto action_11+action_97 x = happyTcHack x happyFail++action_98 x = happyTcHack x happyReduce_90++action_99 (34#) = happyShift action_151+action_99 (41#) = happyShift action_36+action_99 (42#) = happyShift action_37+action_99 (43#) = happyShift action_38+action_99 (44#) = happyShift action_39+action_99 (45#) = happyShift action_40+action_99 (46#) = happyShift action_41+action_99 (47#) = happyShift action_42+action_99 (48#) = happyShift action_43+action_99 (49#) = happyShift action_44+action_99 (50#) = happyShift action_45+action_99 (51#) = happyShift action_46+action_99 (52#) = happyShift action_47+action_99 (53#) = happyShift action_48+action_99 (54#) = happyShift action_49+action_99 (55#) = happyShift action_50+action_99 (56#) = happyShift action_51+action_99 (57#) = happyShift action_52+action_99 (58#) = happyShift action_53+action_99 (59#) = happyShift action_54+action_99 x = happyTcHack x happyFail++action_100 x = happyTcHack x happyReduce_85++action_101 (83#) = happyShift action_28+action_101 (6#) = happyGoto action_150+action_101 x = happyTcHack x happyFail++action_102 (28#) = happyShift action_12+action_102 (29#) = happyShift action_13+action_102 (30#) = happyShift action_14+action_102 (35#) = happyShift action_15+action_102 (42#) = happyShift action_16+action_102 (43#) = happyShift action_17+action_102 (44#) = happyShift action_18+action_102 (50#) = happyShift action_19+action_102 (56#) = happyShift action_20+action_102 (60#) = happyShift action_21+action_102 (61#) = happyShift action_22+action_102 (69#) = happyShift action_23+action_102 (70#) = happyShift action_24+action_102 (74#) = happyShift action_25+action_102 (76#) = happyShift action_26+action_102 (81#) = happyShift action_27+action_102 (83#) = happyShift action_28+action_102 (85#) = happyShift action_29+action_102 (86#) = happyShift action_30+action_102 (87#) = happyShift action_31+action_102 (6#) = happyGoto action_2+action_102 (7#) = happyGoto action_149+action_102 (9#) = happyGoto action_4+action_102 (16#) = happyGoto action_5+action_102 (17#) = happyGoto action_6+action_102 (18#) = happyGoto action_7+action_102 (21#) = happyGoto action_8+action_102 (24#) = happyGoto action_9+action_102 (25#) = happyGoto action_10+action_102 (26#) = happyGoto action_11+action_102 x = happyTcHack x happyFail++action_103 (28#) = happyShift action_12+action_103 (29#) = happyShift action_13+action_103 (30#) = happyShift action_14+action_103 (35#) = happyShift action_15+action_103 (42#) = happyShift action_16+action_103 (43#) = happyShift action_17+action_103 (44#) = happyShift action_18+action_103 (50#) = happyShift action_19+action_103 (56#) = happyShift action_20+action_103 (60#) = happyShift action_21+action_103 (61#) = happyShift action_22+action_103 (69#) = happyShift action_23+action_103 (70#) = happyShift action_24+action_103 (74#) = happyShift action_25+action_103 (76#) = happyShift action_26+action_103 (81#) = happyShift action_27+action_103 (83#) = happyShift action_28+action_103 (85#) = happyShift action_29+action_103 (86#) = happyShift action_30+action_103 (87#) = happyShift action_31+action_103 (6#) = happyGoto action_2+action_103 (7#) = happyGoto action_148+action_103 (9#) = happyGoto action_4+action_103 (16#) = happyGoto action_5+action_103 (17#) = happyGoto action_6+action_103 (18#) = happyGoto action_7+action_103 (21#) = happyGoto action_8+action_103 (24#) = happyGoto action_9+action_103 (25#) = happyGoto action_10+action_103 (26#) = happyGoto action_11+action_103 x = happyTcHack x happyFail++action_104 (28#) = happyShift action_12+action_104 (29#) = happyShift action_13+action_104 (30#) = happyShift action_14+action_104 (35#) = happyShift action_15+action_104 (42#) = happyShift action_16+action_104 (43#) = happyShift action_17+action_104 (44#) = happyShift action_18+action_104 (50#) = happyShift action_19+action_104 (56#) = happyShift action_20+action_104 (60#) = happyShift action_21+action_104 (61#) = happyShift action_22+action_104 (69#) = happyShift action_23+action_104 (70#) = happyShift action_24+action_104 (74#) = happyShift action_25+action_104 (76#) = happyShift action_26+action_104 (81#) = happyShift action_27+action_104 (83#) = happyShift action_28+action_104 (85#) = happyShift action_29+action_104 (86#) = happyShift action_30+action_104 (87#) = happyShift action_31+action_104 (6#) = happyGoto action_2+action_104 (7#) = happyGoto action_147+action_104 (9#) = happyGoto action_4+action_104 (16#) = happyGoto action_5+action_104 (17#) = happyGoto action_6+action_104 (18#) = happyGoto action_7+action_104 (21#) = happyGoto action_8+action_104 (24#) = happyGoto action_9+action_104 (25#) = happyGoto action_10+action_104 (26#) = happyGoto action_11+action_104 x = happyTcHack x happyFail++action_105 x = happyTcHack x happyReduce_98++action_106 (28#) = happyShift action_12+action_106 (29#) = happyShift action_13+action_106 (30#) = happyShift action_14+action_106 (35#) = happyShift action_15+action_106 (42#) = happyShift action_16+action_106 (43#) = happyShift action_17+action_106 (44#) = happyShift action_18+action_106 (50#) = happyShift action_19+action_106 (56#) = happyShift action_20+action_106 (60#) = happyShift action_21+action_106 (61#) = happyShift action_22+action_106 (69#) = happyShift action_23+action_106 (70#) = happyShift action_24+action_106 (74#) = happyShift action_25+action_106 (76#) = happyShift action_26+action_106 (81#) = happyShift action_27+action_106 (83#) = happyShift action_28+action_106 (85#) = happyShift action_29+action_106 (86#) = happyShift action_30+action_106 (87#) = happyShift action_31+action_106 (6#) = happyGoto action_2+action_106 (7#) = happyGoto action_146+action_106 (9#) = happyGoto action_4+action_106 (16#) = happyGoto action_5+action_106 (17#) = happyGoto action_6+action_106 (18#) = happyGoto action_7+action_106 (21#) = happyGoto action_8+action_106 (24#) = happyGoto action_9+action_106 (25#) = happyGoto action_10+action_106 (26#) = happyGoto action_11+action_106 x = happyTcHack x happyFail++action_107 (76#) = happyShift action_145+action_107 x = happyTcHack x happyReduce_67++action_108 (48#) = happyShift action_144+action_108 x = happyTcHack x happyFail++action_109 (28#) = happyShift action_12+action_109 (29#) = happyShift action_13+action_109 (30#) = happyShift action_14+action_109 (35#) = happyShift action_15+action_109 (42#) = happyShift action_16+action_109 (43#) = happyShift action_17+action_109 (44#) = happyShift action_18+action_109 (50#) = happyShift action_19+action_109 (56#) = happyShift action_20+action_109 (60#) = happyShift action_21+action_109 (61#) = happyShift action_22+action_109 (69#) = happyShift action_23+action_109 (70#) = happyShift action_24+action_109 (74#) = happyShift action_25+action_109 (76#) = happyShift action_26+action_109 (81#) = happyShift action_27+action_109 (83#) = happyShift action_28+action_109 (85#) = happyShift action_29+action_109 (86#) = happyShift action_30+action_109 (87#) = happyShift action_31+action_109 (6#) = happyGoto action_2+action_109 (7#) = happyGoto action_143+action_109 (9#) = happyGoto action_4+action_109 (16#) = happyGoto action_5+action_109 (17#) = happyGoto action_6+action_109 (18#) = happyGoto action_7+action_109 (21#) = happyGoto action_8+action_109 (24#) = happyGoto action_9+action_109 (25#) = happyGoto action_10+action_109 (26#) = happyGoto action_11+action_109 x = happyTcHack x happyFail++action_110 (83#) = happyShift action_28+action_110 (6#) = happyGoto action_142+action_110 x = happyTcHack x happyFail++action_111 (28#) = happyShift action_12+action_111 (29#) = happyShift action_13+action_111 (30#) = happyShift action_14+action_111 (35#) = happyShift action_15+action_111 (42#) = happyShift action_16+action_111 (43#) = happyShift action_17+action_111 (44#) = happyShift action_18+action_111 (50#) = happyShift action_19+action_111 (56#) = happyShift action_20+action_111 (60#) = happyShift action_21+action_111 (61#) = happyShift action_22+action_111 (69#) = happyShift action_23+action_111 (70#) = happyShift action_24+action_111 (74#) = happyShift action_25+action_111 (76#) = happyShift action_26+action_111 (81#) = happyShift action_27+action_111 (83#) = happyShift action_28+action_111 (85#) = happyShift action_29+action_111 (86#) = happyShift action_30+action_111 (87#) = happyShift action_31+action_111 (6#) = happyGoto action_2+action_111 (7#) = happyGoto action_141+action_111 (9#) = happyGoto action_4+action_111 (16#) = happyGoto action_5+action_111 (17#) = happyGoto action_6+action_111 (18#) = happyGoto action_7+action_111 (21#) = happyGoto action_8+action_111 (24#) = happyGoto action_9+action_111 (25#) = happyGoto action_10+action_111 (26#) = happyGoto action_11+action_111 x = happyTcHack x happyFail++action_112 (36#) = happyShift action_140+action_112 x = happyTcHack x happyFail++action_113 (36#) = happyShift action_139+action_113 x = happyTcHack x happyFail++action_114 (75#) = happyShift action_77+action_114 (23#) = happyGoto action_100+action_114 x = happyTcHack x happyReduce_83++action_115 (36#) = happyShift action_138+action_115 (63#) = happyShift action_106+action_115 x = happyTcHack x happyFail++action_116 x = happyTcHack x happyReduce_101++action_117 (41#) = happyShift action_36+action_117 (42#) = happyShift action_37+action_117 (43#) = happyShift action_38+action_117 (44#) = happyShift action_39+action_117 (45#) = happyShift action_40+action_117 (46#) = happyShift action_41+action_117 (47#) = happyShift action_42+action_117 (48#) = happyShift action_43+action_117 (49#) = happyShift action_44+action_117 (50#) = happyShift action_45+action_117 (51#) = happyShift action_46+action_117 (52#) = happyShift action_47+action_117 (53#) = happyShift action_48+action_117 (54#) = happyShift action_49+action_117 (55#) = happyShift action_50+action_117 (56#) = happyShift action_51+action_117 x = happyTcHack x happyReduce_33++action_118 (41#) = happyShift action_36+action_118 (42#) = happyShift action_37+action_118 (43#) = happyShift action_38+action_118 (44#) = happyShift action_39+action_118 (45#) = happyShift action_40+action_118 (46#) = happyShift action_41+action_118 (47#) = happyShift action_42+action_118 (48#) = happyShift action_43+action_118 (49#) = happyShift action_44+action_118 (50#) = happyShift action_45+action_118 (51#) = happyShift action_46+action_118 (52#) = happyShift action_47+action_118 (53#) = happyShift action_48+action_118 (54#) = happyShift action_49+action_118 (55#) = happyShift action_50+action_118 (56#) = happyShift action_51+action_118 x = happyTcHack x happyReduce_32++action_119 (41#) = happyShift action_36+action_119 (42#) = happyShift action_37+action_119 (43#) = happyShift action_38+action_119 (44#) = happyShift action_39+action_119 (45#) = happyShift action_40+action_119 (46#) = happyShift action_41+action_119 (47#) = happyShift action_42+action_119 (48#) = happyShift action_43+action_119 (49#) = happyShift action_44+action_119 (50#) = happyShift action_45+action_119 (51#) = happyShift action_46+action_119 (52#) = happyShift action_47+action_119 (53#) = happyShift action_48+action_119 (54#) = happyShift action_49+action_119 (55#) = happyShift action_50+action_119 (56#) = happyShift action_51+action_119 x = happyTcHack x happyReduce_31++action_120 (41#) = happyShift action_36+action_120 (42#) = happyShift action_37+action_120 (43#) = happyShift action_38+action_120 (44#) = happyShift action_39+action_120 (45#) = happyShift action_40+action_120 (46#) = happyShift action_41+action_120 (47#) = happyShift action_42+action_120 (48#) = happyShift action_43+action_120 (49#) = happyShift action_44+action_120 (50#) = happyShift action_45+action_120 (51#) = happyShift action_46+action_120 (52#) = happyShift action_47+action_120 (53#) = happyShift action_48+action_120 (56#) = happyFail+action_120 x = happyTcHack x happyReduce_30++action_121 (41#) = happyShift action_36+action_121 (42#) = happyShift action_37+action_121 (43#) = happyShift action_38+action_121 (44#) = happyShift action_39+action_121 (45#) = happyShift action_40+action_121 (46#) = happyShift action_41+action_121 (47#) = happyShift action_42+action_121 (48#) = happyShift action_43+action_121 (49#) = happyShift action_44+action_121 (50#) = happyShift action_45+action_121 (51#) = happyShift action_46+action_121 (52#) = happyShift action_47+action_121 (53#) = happyShift action_48+action_121 (54#) = happyShift action_49+action_121 (55#) = happyShift action_50+action_121 (56#) = happyShift action_51+action_121 x = happyTcHack x happyReduce_29++action_122 (41#) = happyShift action_36+action_122 (42#) = happyShift action_37+action_122 (43#) = happyShift action_38+action_122 (44#) = happyShift action_39+action_122 (45#) = happyShift action_40+action_122 (46#) = happyShift action_41+action_122 (47#) = happyShift action_42+action_122 (48#) = happyShift action_43+action_122 (49#) = happyShift action_44+action_122 (50#) = happyShift action_45+action_122 (51#) = happyShift action_46+action_122 (52#) = happyShift action_47+action_122 (53#) = happyShift action_48+action_122 (54#) = happyShift action_49+action_122 (56#) = happyShift action_51+action_122 x = happyTcHack x happyReduce_28++action_123 (42#) = happyShift action_37+action_123 (43#) = happyShift action_38+action_123 (44#) = happyShift action_39+action_123 (45#) = happyShift action_40+action_123 (46#) = happyShift action_41+action_123 (47#) = happyShift action_42+action_123 x = happyTcHack x happyReduce_27++action_124 (42#) = happyShift action_37+action_124 (43#) = happyShift action_38+action_124 (44#) = happyShift action_39+action_124 (45#) = happyShift action_40+action_124 (46#) = happyShift action_41+action_124 (47#) = happyShift action_42+action_124 x = happyTcHack x happyReduce_26++action_125 (42#) = happyShift action_37+action_125 (43#) = happyShift action_38+action_125 (44#) = happyShift action_39+action_125 (45#) = happyShift action_40+action_125 (46#) = happyShift action_41+action_125 (47#) = happyShift action_42+action_125 x = happyTcHack x happyReduce_25++action_126 (42#) = happyShift action_37+action_126 (43#) = happyShift action_38+action_126 (44#) = happyShift action_39+action_126 (45#) = happyShift action_40+action_126 (46#) = happyShift action_41+action_126 (47#) = happyShift action_42+action_126 x = happyTcHack x happyReduce_24++action_127 (42#) = happyShift action_37+action_127 (43#) = happyShift action_38+action_127 (44#) = happyShift action_39+action_127 (45#) = happyShift action_40+action_127 (46#) = happyShift action_41+action_127 (47#) = happyShift action_42+action_127 x = happyTcHack x happyReduce_23++action_128 (42#) = happyShift action_37+action_128 (43#) = happyShift action_38+action_128 (44#) = happyShift action_39+action_128 (45#) = happyShift action_40+action_128 (46#) = happyShift action_41+action_128 (47#) = happyShift action_42+action_128 x = happyTcHack x happyReduce_22++action_129 x = happyTcHack x happyReduce_21++action_130 x = happyTcHack x happyReduce_20++action_131 x = happyTcHack x happyReduce_19++action_132 x = happyTcHack x happyReduce_18++action_133 (44#) = happyShift action_39+action_133 (45#) = happyShift action_40+action_133 (46#) = happyShift action_41+action_133 (47#) = happyShift action_42+action_133 x = happyTcHack x happyReduce_17++action_134 (44#) = happyShift action_39+action_134 (45#) = happyShift action_40+action_134 (46#) = happyShift action_41+action_134 (47#) = happyShift action_42+action_134 x = happyTcHack x happyReduce_16++action_135 (42#) = happyShift action_37+action_135 (43#) = happyShift action_38+action_135 (44#) = happyShift action_39+action_135 (45#) = happyShift action_40+action_135 (46#) = happyShift action_41+action_135 (47#) = happyShift action_42+action_135 (48#) = happyShift action_43+action_135 (49#) = happyShift action_44+action_135 (50#) = happyShift action_45+action_135 (51#) = happyShift action_46+action_135 (52#) = happyShift action_47+action_135 (53#) = happyShift action_48+action_135 x = happyTcHack x happyReduce_15++action_136 (35#) = happyShift action_137+action_136 x = happyTcHack x happyFail++action_137 (36#) = happyShift action_184+action_137 (83#) = happyShift action_28+action_137 (5#) = happyGoto action_182+action_137 (6#) = happyGoto action_183+action_137 x = happyTcHack x happyFail++action_138 x = happyTcHack x happyReduce_100++action_139 x = happyTcHack x happyReduce_62++action_140 x = happyTcHack x happyReduce_61++action_141 (41#) = happyShift action_36+action_141 (42#) = happyShift action_37+action_141 (43#) = happyShift action_38+action_141 (44#) = happyShift action_39+action_141 (45#) = happyShift action_40+action_141 (46#) = happyShift action_41+action_141 (47#) = happyShift action_42+action_141 (48#) = happyShift action_43+action_141 (49#) = happyShift action_44+action_141 (50#) = happyShift action_45+action_141 (51#) = happyShift action_46+action_141 (52#) = happyShift action_47+action_141 (53#) = happyShift action_48+action_141 (54#) = happyShift action_49+action_141 (55#) = happyShift action_50+action_141 (56#) = happyShift action_51+action_141 (57#) = happyShift action_52+action_141 (58#) = happyShift action_53+action_141 (59#) = happyShift action_54+action_141 x = happyTcHack x happyReduce_50++action_142 (64#) = happyShift action_181+action_142 x = happyTcHack x happyFail++action_143 (41#) = happyShift action_36+action_143 (42#) = happyShift action_37+action_143 (43#) = happyShift action_38+action_143 (44#) = happyShift action_39+action_143 (45#) = happyShift action_40+action_143 (46#) = happyShift action_41+action_143 (47#) = happyShift action_42+action_143 (48#) = happyShift action_43+action_143 (49#) = happyShift action_44+action_143 (50#) = happyShift action_45+action_143 (51#) = happyShift action_46+action_143 (52#) = happyShift action_47+action_143 (53#) = happyShift action_48+action_143 (54#) = happyShift action_49+action_143 (55#) = happyShift action_50+action_143 (56#) = happyShift action_51+action_143 (57#) = happyShift action_52+action_143 (58#) = happyShift action_53+action_143 (59#) = happyShift action_54+action_143 (79#) = happyShift action_180+action_143 x = happyTcHack x happyReduce_46++action_144 (39#) = happyShift action_178+action_144 (87#) = happyShift action_179+action_144 x = happyTcHack x happyFail++action_145 (48#) = happyShift action_177+action_145 x = happyTcHack x happyFail++action_146 (41#) = happyShift action_36+action_146 (42#) = happyShift action_37+action_146 (43#) = happyShift action_38+action_146 (44#) = happyShift action_39+action_146 (45#) = happyShift action_40+action_146 (46#) = happyShift action_41+action_146 (47#) = happyShift action_42+action_146 (48#) = happyShift action_43+action_146 (49#) = happyShift action_44+action_146 (50#) = happyShift action_45+action_146 (51#) = happyShift action_46+action_146 (52#) = happyShift action_47+action_146 (53#) = happyShift action_48+action_146 (54#) = happyShift action_49+action_146 (55#) = happyShift action_50+action_146 (56#) = happyShift action_51+action_146 (57#) = happyShift action_52+action_146 (58#) = happyShift action_53+action_146 (59#) = happyShift action_54+action_146 x = happyTcHack x happyReduce_41++action_147 (32#) = happyShift action_176+action_147 (41#) = happyShift action_36+action_147 (42#) = happyShift action_37+action_147 (43#) = happyShift action_38+action_147 (44#) = happyShift action_39+action_147 (45#) = happyShift action_40+action_147 (46#) = happyShift action_41+action_147 (47#) = happyShift action_42+action_147 (48#) = happyShift action_43+action_147 (49#) = happyShift action_44+action_147 (50#) = happyShift action_45+action_147 (51#) = happyShift action_46+action_147 (52#) = happyShift action_47+action_147 (53#) = happyShift action_48+action_147 (54#) = happyShift action_49+action_147 (55#) = happyShift action_50+action_147 (56#) = happyShift action_51+action_147 (57#) = happyShift action_52+action_147 (58#) = happyShift action_53+action_147 (59#) = happyShift action_54+action_147 x = happyTcHack x happyFail++action_148 (41#) = happyShift action_36+action_148 (42#) = happyShift action_37+action_148 (43#) = happyShift action_38+action_148 (44#) = happyShift action_39+action_148 (45#) = happyShift action_40+action_148 (46#) = happyShift action_41+action_148 (47#) = happyShift action_42+action_148 (48#) = happyShift action_43+action_148 (49#) = happyShift action_44+action_148 (50#) = happyShift action_45+action_148 (51#) = happyShift action_46+action_148 (52#) = happyShift action_47+action_148 (53#) = happyShift action_48+action_148 (54#) = happyShift action_49+action_148 (55#) = happyShift action_50+action_148 (56#) = happyShift action_51+action_148 (57#) = happyShift action_52+action_148 (58#) = happyShift action_53+action_148 (59#) = happyShift action_54+action_148 x = happyTcHack x happyReduce_10++action_149 (41#) = happyShift action_36+action_149 (42#) = happyShift action_37+action_149 (43#) = happyShift action_38+action_149 (44#) = happyShift action_39+action_149 (45#) = happyShift action_40+action_149 (46#) = happyShift action_41+action_149 (47#) = happyShift action_42+action_149 (48#) = happyShift action_43+action_149 (49#) = happyShift action_44+action_149 (50#) = happyShift action_45+action_149 (51#) = happyShift action_46+action_149 (52#) = happyShift action_47+action_149 (53#) = happyShift action_48+action_149 (54#) = happyShift action_49+action_149 (55#) = happyShift action_50+action_149 (56#) = happyShift action_51+action_149 (57#) = happyShift action_52+action_149 (58#) = happyShift action_53+action_149 (59#) = happyShift action_54+action_149 x = happyTcHack x happyReduce_9++action_150 (62#) = happyShift action_175+action_150 x = happyTcHack x happyFail++action_151 x = happyTcHack x happyReduce_92++action_152 (33#) = happyShift action_76+action_152 x = happyTcHack x happyReduce_88++action_153 (35#) = happyShift action_15+action_153 (44#) = happyShift action_18+action_153 (76#) = happyShift action_26+action_153 (81#) = happyShift action_27+action_153 (83#) = happyShift action_28+action_153 (6#) = happyGoto action_2+action_153 (24#) = happyGoto action_174+action_153 (25#) = happyGoto action_10+action_153 (26#) = happyGoto action_11+action_153 x = happyTcHack x happyFail++action_154 (33#) = happyShift action_76+action_154 x = happyTcHack x happyReduce_87++action_155 (52#) = happyShift action_173+action_155 x = happyTcHack x happyFail++action_156 (38#) = happyShift action_172+action_156 (63#) = happyShift action_106+action_156 x = happyTcHack x happyFail++action_157 x = happyTcHack x happyReduce_75++action_158 (28#) = happyShift action_12+action_158 (29#) = happyShift action_13+action_158 (30#) = happyShift action_14+action_158 (35#) = happyShift action_15+action_158 (42#) = happyShift action_16+action_158 (43#) = happyShift action_17+action_158 (44#) = happyShift action_18+action_158 (50#) = happyShift action_19+action_158 (56#) = happyShift action_20+action_158 (60#) = happyShift action_21+action_158 (61#) = happyShift action_22+action_158 (69#) = happyShift action_23+action_158 (70#) = happyShift action_24+action_158 (74#) = happyShift action_25+action_158 (76#) = happyShift action_26+action_158 (81#) = happyShift action_27+action_158 (83#) = happyShift action_28+action_158 (85#) = happyShift action_29+action_158 (86#) = happyShift action_30+action_158 (87#) = happyShift action_31+action_158 (6#) = happyGoto action_2+action_158 (7#) = happyGoto action_68+action_158 (8#) = happyGoto action_171+action_158 (9#) = happyGoto action_4+action_158 (16#) = happyGoto action_5+action_158 (17#) = happyGoto action_6+action_158 (18#) = happyGoto action_7+action_158 (21#) = happyGoto action_8+action_158 (24#) = happyGoto action_9+action_158 (25#) = happyGoto action_10+action_158 (26#) = happyGoto action_11+action_158 x = happyTcHack x happyFail++action_159 (76#) = happyShift action_170+action_159 x = happyTcHack x happyFail++action_160 x = happyTcHack x happyReduce_74++action_161 x = happyTcHack x happyReduce_73++action_162 (41#) = happyShift action_36+action_162 (42#) = happyShift action_37+action_162 (43#) = happyShift action_38+action_162 (44#) = happyShift action_39+action_162 (45#) = happyShift action_40+action_162 (46#) = happyShift action_41+action_162 (47#) = happyShift action_42+action_162 (48#) = happyShift action_43+action_162 (49#) = happyShift action_44+action_162 (50#) = happyShift action_45+action_162 (51#) = happyShift action_46+action_162 (52#) = happyShift action_47+action_162 (53#) = happyShift action_48+action_162 (54#) = happyShift action_49+action_162 (55#) = happyShift action_50+action_162 (56#) = happyShift action_51+action_162 (57#) = happyShift action_52+action_162 (58#) = happyShift action_53+action_162 (59#) = happyShift action_54+action_162 (67#) = happyShift action_168+action_162 (68#) = happyShift action_169+action_162 (15#) = happyGoto action_167+action_162 x = happyTcHack x happyReduce_60++action_163 (63#) = happyShift action_166+action_163 x = happyTcHack x happyReduce_54++action_164 (28#) = happyShift action_12+action_164 (29#) = happyShift action_13+action_164 (30#) = happyShift action_14+action_164 (35#) = happyShift action_15+action_164 (42#) = happyShift action_16+action_164 (43#) = happyShift action_17+action_164 (44#) = happyShift action_18+action_164 (50#) = happyShift action_19+action_164 (56#) = happyShift action_20+action_164 (60#) = happyShift action_21+action_164 (61#) = happyShift action_22+action_164 (69#) = happyShift action_23+action_164 (70#) = happyShift action_24+action_164 (74#) = happyShift action_25+action_164 (76#) = happyShift action_26+action_164 (81#) = happyShift action_27+action_164 (83#) = happyShift action_28+action_164 (85#) = happyShift action_29+action_164 (86#) = happyShift action_30+action_164 (87#) = happyShift action_31+action_164 (6#) = happyGoto action_2+action_164 (7#) = happyGoto action_165+action_164 (9#) = happyGoto action_4+action_164 (16#) = happyGoto action_5+action_164 (17#) = happyGoto action_6+action_164 (18#) = happyGoto action_7+action_164 (21#) = happyGoto action_8+action_164 (24#) = happyGoto action_9+action_164 (25#) = happyGoto action_10+action_164 (26#) = happyGoto action_11+action_164 x = happyTcHack x happyFail++action_165 (41#) = happyShift action_36+action_165 (42#) = happyShift action_37+action_165 (43#) = happyShift action_38+action_165 (44#) = happyShift action_39+action_165 (45#) = happyShift action_40+action_165 (46#) = happyShift action_41+action_165 (47#) = happyShift action_42+action_165 (48#) = happyShift action_43+action_165 (49#) = happyShift action_44+action_165 (50#) = happyShift action_45+action_165 (51#) = happyShift action_46+action_165 (52#) = happyShift action_47+action_165 (53#) = happyShift action_48+action_165 (54#) = happyShift action_49+action_165 (55#) = happyShift action_50+action_165 (56#) = happyShift action_51+action_165 (57#) = happyShift action_52+action_165 (58#) = happyShift action_53+action_165 (59#) = happyShift action_54+action_165 x = happyTcHack x happyReduce_8++action_166 (28#) = happyShift action_12+action_166 (29#) = happyShift action_13+action_166 (30#) = happyShift action_14+action_166 (35#) = happyShift action_15+action_166 (42#) = happyShift action_16+action_166 (43#) = happyShift action_17+action_166 (44#) = happyShift action_18+action_166 (50#) = happyShift action_19+action_166 (56#) = happyShift action_20+action_166 (60#) = happyShift action_21+action_166 (61#) = happyShift action_22+action_166 (69#) = happyShift action_23+action_166 (70#) = happyShift action_24+action_166 (74#) = happyShift action_25+action_166 (76#) = happyShift action_26+action_166 (81#) = happyShift action_27+action_166 (83#) = happyShift action_28+action_166 (85#) = happyShift action_29+action_166 (86#) = happyShift action_30+action_166 (87#) = happyShift action_31+action_166 (6#) = happyGoto action_2+action_166 (7#) = happyGoto action_197+action_166 (9#) = happyGoto action_4+action_166 (16#) = happyGoto action_5+action_166 (17#) = happyGoto action_6+action_166 (18#) = happyGoto action_7+action_166 (21#) = happyGoto action_8+action_166 (24#) = happyGoto action_9+action_166 (25#) = happyGoto action_10+action_166 (26#) = happyGoto action_11+action_166 x = happyTcHack x happyFail++action_167 x = happyTcHack x happyReduce_56++action_168 x = happyTcHack x happyReduce_58++action_169 x = happyTcHack x happyReduce_59++action_170 (52#) = happyShift action_196+action_170 x = happyTcHack x happyFail++action_171 (38#) = happyShift action_195+action_171 (63#) = happyShift action_106+action_171 x = happyTcHack x happyFail++action_172 x = happyTcHack x happyReduce_68++action_173 x = happyTcHack x happyReduce_64++action_174 (33#) = happyShift action_76+action_174 x = happyTcHack x happyReduce_89++action_175 (28#) = happyShift action_12+action_175 (29#) = happyShift action_13+action_175 (30#) = happyShift action_14+action_175 (35#) = happyShift action_15+action_175 (42#) = happyShift action_16+action_175 (43#) = happyShift action_17+action_175 (44#) = happyShift action_18+action_175 (50#) = happyShift action_19+action_175 (56#) = happyShift action_20+action_175 (60#) = happyShift action_21+action_175 (61#) = happyShift action_22+action_175 (69#) = happyShift action_23+action_175 (70#) = happyShift action_24+action_175 (74#) = happyShift action_25+action_175 (76#) = happyShift action_26+action_175 (81#) = happyShift action_27+action_175 (83#) = happyShift action_28+action_175 (85#) = happyShift action_29+action_175 (86#) = happyShift action_30+action_175 (87#) = happyShift action_31+action_175 (6#) = happyGoto action_2+action_175 (7#) = happyGoto action_194+action_175 (9#) = happyGoto action_4+action_175 (16#) = happyGoto action_5+action_175 (17#) = happyGoto action_6+action_175 (18#) = happyGoto action_7+action_175 (21#) = happyGoto action_8+action_175 (24#) = happyGoto action_9+action_175 (25#) = happyGoto action_10+action_175 (26#) = happyGoto action_11+action_175 x = happyTcHack x happyFail++action_176 (28#) = happyShift action_12+action_176 (29#) = happyShift action_13+action_176 (30#) = happyShift action_14+action_176 (35#) = happyShift action_15+action_176 (42#) = happyShift action_16+action_176 (43#) = happyShift action_17+action_176 (44#) = happyShift action_18+action_176 (50#) = happyShift action_19+action_176 (56#) = happyShift action_20+action_176 (60#) = happyShift action_21+action_176 (61#) = happyShift action_22+action_176 (69#) = happyShift action_23+action_176 (70#) = happyShift action_24+action_176 (74#) = happyShift action_25+action_176 (76#) = happyShift action_26+action_176 (81#) = happyShift action_27+action_176 (83#) = happyShift action_28+action_176 (85#) = happyShift action_29+action_176 (86#) = happyShift action_30+action_176 (87#) = happyShift action_31+action_176 (6#) = happyGoto action_2+action_176 (7#) = happyGoto action_193+action_176 (9#) = happyGoto action_4+action_176 (16#) = happyGoto action_5+action_176 (17#) = happyGoto action_6+action_176 (18#) = happyGoto action_7+action_176 (21#) = happyGoto action_8+action_176 (24#) = happyGoto action_9+action_176 (25#) = happyGoto action_10+action_176 (26#) = happyGoto action_11+action_176 x = happyTcHack x happyFail++action_177 (39#) = happyShift action_191+action_177 (87#) = happyShift action_192+action_177 x = happyTcHack x happyFail++action_178 (28#) = happyShift action_12+action_178 (29#) = happyShift action_13+action_178 (30#) = happyShift action_14+action_178 (35#) = happyShift action_15+action_178 (42#) = happyShift action_16+action_178 (43#) = happyShift action_17+action_178 (44#) = happyShift action_18+action_178 (50#) = happyShift action_19+action_178 (56#) = happyShift action_20+action_178 (60#) = happyShift action_21+action_178 (61#) = happyShift action_22+action_178 (69#) = happyShift action_23+action_178 (70#) = happyShift action_24+action_178 (74#) = happyShift action_25+action_178 (76#) = happyShift action_26+action_178 (81#) = happyShift action_27+action_178 (83#) = happyShift action_28+action_178 (85#) = happyShift action_29+action_178 (86#) = happyShift action_30+action_178 (87#) = happyShift action_31+action_178 (6#) = happyGoto action_2+action_178 (7#) = happyGoto action_190+action_178 (9#) = happyGoto action_4+action_178 (16#) = happyGoto action_5+action_178 (17#) = happyGoto action_6+action_178 (18#) = happyGoto action_7+action_178 (21#) = happyGoto action_8+action_178 (24#) = happyGoto action_9+action_178 (25#) = happyGoto action_10+action_178 (26#) = happyGoto action_11+action_178 x = happyTcHack x happyFail++action_179 x = happyTcHack x happyReduce_76++action_180 (83#) = happyShift action_28+action_180 (6#) = happyGoto action_189+action_180 x = happyTcHack x happyFail++action_181 (28#) = happyShift action_12+action_181 (29#) = happyShift action_13+action_181 (30#) = happyShift action_14+action_181 (35#) = happyShift action_15+action_181 (42#) = happyShift action_16+action_181 (43#) = happyShift action_17+action_181 (44#) = happyShift action_18+action_181 (50#) = happyShift action_19+action_181 (56#) = happyShift action_20+action_181 (60#) = happyShift action_21+action_181 (61#) = happyShift action_22+action_181 (69#) = happyShift action_23+action_181 (70#) = happyShift action_24+action_181 (74#) = happyShift action_25+action_181 (76#) = happyShift action_26+action_181 (81#) = happyShift action_27+action_181 (83#) = happyShift action_28+action_181 (85#) = happyShift action_29+action_181 (86#) = happyShift action_30+action_181 (87#) = happyShift action_31+action_181 (6#) = happyGoto action_2+action_181 (7#) = happyGoto action_188+action_181 (9#) = happyGoto action_4+action_181 (16#) = happyGoto action_5+action_181 (17#) = happyGoto action_6+action_181 (18#) = happyGoto action_7+action_181 (21#) = happyGoto action_8+action_181 (24#) = happyGoto action_9+action_181 (25#) = happyGoto action_10+action_181 (26#) = happyGoto action_11+action_181 x = happyTcHack x happyFail++action_182 (36#) = happyShift action_186+action_182 (63#) = happyShift action_187+action_182 x = happyTcHack x happyFail++action_183 x = happyTcHack x happyReduce_5++action_184 (48#) = happyShift action_185+action_184 x = happyTcHack x happyFail++action_185 (28#) = happyShift action_12+action_185 (29#) = happyShift action_13+action_185 (30#) = happyShift action_14+action_185 (35#) = happyShift action_15+action_185 (42#) = happyShift action_16+action_185 (43#) = happyShift action_17+action_185 (44#) = happyShift action_18+action_185 (50#) = happyShift action_19+action_185 (56#) = happyShift action_20+action_185 (60#) = happyShift action_21+action_185 (61#) = happyShift action_22+action_185 (69#) = happyShift action_23+action_185 (70#) = happyShift action_24+action_185 (74#) = happyShift action_25+action_185 (76#) = happyShift action_26+action_185 (81#) = happyShift action_27+action_185 (83#) = happyShift action_28+action_185 (85#) = happyShift action_29+action_185 (86#) = happyShift action_30+action_185 (87#) = happyShift action_31+action_185 (6#) = happyGoto action_2+action_185 (7#) = happyGoto action_204+action_185 (9#) = happyGoto action_4+action_185 (16#) = happyGoto action_5+action_185 (17#) = happyGoto action_6+action_185 (18#) = happyGoto action_7+action_185 (21#) = happyGoto action_8+action_185 (24#) = happyGoto action_9+action_185 (25#) = happyGoto action_10+action_185 (26#) = happyGoto action_11+action_185 x = happyTcHack x happyFail++action_186 (48#) = happyShift action_203+action_186 x = happyTcHack x happyFail++action_187 (83#) = happyShift action_28+action_187 (6#) = happyGoto action_202+action_187 x = happyTcHack x happyFail++action_188 (41#) = happyShift action_36+action_188 (42#) = happyShift action_37+action_188 (43#) = happyShift action_38+action_188 (44#) = happyShift action_39+action_188 (45#) = happyShift action_40+action_188 (46#) = happyShift action_41+action_188 (47#) = happyShift action_42+action_188 (48#) = happyShift action_43+action_188 (49#) = happyShift action_44+action_188 (50#) = happyShift action_45+action_188 (51#) = happyShift action_46+action_188 (52#) = happyShift action_47+action_188 (53#) = happyShift action_48+action_188 (54#) = happyShift action_49+action_188 (55#) = happyShift action_50+action_188 (56#) = happyShift action_51+action_188 (57#) = happyShift action_52+action_188 (58#) = happyShift action_53+action_188 (59#) = happyShift action_54+action_188 x = happyTcHack x happyReduce_51++action_189 x = happyTcHack x happyReduce_47++action_190 (40#) = happyShift action_201+action_190 (41#) = happyShift action_36+action_190 (42#) = happyShift action_37+action_190 (43#) = happyShift action_38+action_190 (44#) = happyShift action_39+action_190 (45#) = happyShift action_40+action_190 (46#) = happyShift action_41+action_190 (47#) = happyShift action_42+action_190 (48#) = happyShift action_43+action_190 (49#) = happyShift action_44+action_190 (50#) = happyShift action_45+action_190 (51#) = happyShift action_46+action_190 (52#) = happyShift action_47+action_190 (53#) = happyShift action_48+action_190 (54#) = happyShift action_49+action_190 (55#) = happyShift action_50+action_190 (56#) = happyShift action_51+action_190 (57#) = happyShift action_52+action_190 (58#) = happyShift action_53+action_190 (59#) = happyShift action_54+action_190 x = happyTcHack x happyFail++action_191 (28#) = happyShift action_12+action_191 (29#) = happyShift action_13+action_191 (30#) = happyShift action_14+action_191 (35#) = happyShift action_15+action_191 (42#) = happyShift action_16+action_191 (43#) = happyShift action_17+action_191 (44#) = happyShift action_18+action_191 (50#) = happyShift action_19+action_191 (56#) = happyShift action_20+action_191 (60#) = happyShift action_21+action_191 (61#) = happyShift action_22+action_191 (69#) = happyShift action_23+action_191 (70#) = happyShift action_24+action_191 (74#) = happyShift action_25+action_191 (76#) = happyShift action_26+action_191 (81#) = happyShift action_27+action_191 (83#) = happyShift action_28+action_191 (85#) = happyShift action_29+action_191 (86#) = happyShift action_30+action_191 (87#) = happyShift action_31+action_191 (6#) = happyGoto action_2+action_191 (7#) = happyGoto action_200+action_191 (9#) = happyGoto action_4+action_191 (16#) = happyGoto action_5+action_191 (17#) = happyGoto action_6+action_191 (18#) = happyGoto action_7+action_191 (21#) = happyGoto action_8+action_191 (24#) = happyGoto action_9+action_191 (25#) = happyGoto action_10+action_191 (26#) = happyGoto action_11+action_191 x = happyTcHack x happyFail++action_192 x = happyTcHack x happyReduce_78++action_193 (41#) = happyShift action_36+action_193 (42#) = happyShift action_37+action_193 (43#) = happyShift action_38+action_193 (44#) = happyShift action_39+action_193 (45#) = happyShift action_40+action_193 (46#) = happyShift action_41+action_193 (47#) = happyShift action_42+action_193 (48#) = happyShift action_43+action_193 (49#) = happyShift action_44+action_193 (50#) = happyShift action_45+action_193 (51#) = happyShift action_46+action_193 (52#) = happyShift action_47+action_193 (53#) = happyShift action_48+action_193 (54#) = happyShift action_49+action_193 (55#) = happyShift action_50+action_193 (56#) = happyShift action_51+action_193 (57#) = happyShift action_52+action_193 (58#) = happyShift action_53+action_193 (59#) = happyShift action_54+action_193 x = happyTcHack x happyReduce_11++action_194 (41#) = happyShift action_36+action_194 (42#) = happyShift action_37+action_194 (43#) = happyShift action_38+action_194 (44#) = happyShift action_39+action_194 (45#) = happyShift action_40+action_194 (46#) = happyShift action_41+action_194 (47#) = happyShift action_42+action_194 (48#) = happyShift action_43+action_194 (49#) = happyShift action_44+action_194 (50#) = happyShift action_45+action_194 (51#) = happyShift action_46+action_194 (52#) = happyShift action_47+action_194 (53#) = happyShift action_48+action_194 (54#) = happyShift action_49+action_194 (55#) = happyShift action_50+action_194 (56#) = happyShift action_51+action_194 (57#) = happyShift action_52+action_194 (58#) = happyShift action_53+action_194 (59#) = happyShift action_54+action_194 (79#) = happyShift action_199+action_194 x = happyTcHack x happyReduce_48++action_195 x = happyTcHack x happyReduce_72++action_196 x = happyTcHack x happyReduce_63++action_197 (41#) = happyShift action_36+action_197 (42#) = happyShift action_37+action_197 (43#) = happyShift action_38+action_197 (44#) = happyShift action_39+action_197 (45#) = happyShift action_40+action_197 (46#) = happyShift action_41+action_197 (47#) = happyShift action_42+action_197 (48#) = happyShift action_43+action_197 (49#) = happyShift action_44+action_197 (50#) = happyShift action_45+action_197 (51#) = happyShift action_46+action_197 (52#) = happyShift action_47+action_197 (53#) = happyShift action_48+action_197 (54#) = happyShift action_49+action_197 (55#) = happyShift action_50+action_197 (56#) = happyShift action_51+action_197 (57#) = happyShift action_52+action_197 (58#) = happyShift action_53+action_197 (59#) = happyShift action_54+action_197 (67#) = happyShift action_168+action_197 (68#) = happyShift action_169+action_197 (15#) = happyGoto action_198+action_197 x = happyTcHack x happyReduce_60++action_198 x = happyTcHack x happyReduce_57++action_199 (83#) = happyShift action_28+action_199 (6#) = happyGoto action_208+action_199 x = happyTcHack x happyFail++action_200 (40#) = happyShift action_207+action_200 (41#) = happyShift action_36+action_200 (42#) = happyShift action_37+action_200 (43#) = happyShift action_38+action_200 (44#) = happyShift action_39+action_200 (45#) = happyShift action_40+action_200 (46#) = happyShift action_41+action_200 (47#) = happyShift action_42+action_200 (48#) = happyShift action_43+action_200 (49#) = happyShift action_44+action_200 (50#) = happyShift action_45+action_200 (51#) = happyShift action_46+action_200 (52#) = happyShift action_47+action_200 (53#) = happyShift action_48+action_200 (54#) = happyShift action_49+action_200 (55#) = happyShift action_50+action_200 (56#) = happyShift action_51+action_200 (57#) = happyShift action_52+action_200 (58#) = happyShift action_53+action_200 (59#) = happyShift action_54+action_200 x = happyTcHack x happyFail++action_201 x = happyTcHack x happyReduce_77++action_202 x = happyTcHack x happyReduce_6++action_203 (28#) = happyShift action_12+action_203 (29#) = happyShift action_13+action_203 (30#) = happyShift action_14+action_203 (35#) = happyShift action_15+action_203 (42#) = happyShift action_16+action_203 (43#) = happyShift action_17+action_203 (44#) = happyShift action_18+action_203 (50#) = happyShift action_19+action_203 (56#) = happyShift action_20+action_203 (60#) = happyShift action_21+action_203 (61#) = happyShift action_22+action_203 (69#) = happyShift action_23+action_203 (70#) = happyShift action_24+action_203 (74#) = happyShift action_25+action_203 (76#) = happyShift action_26+action_203 (81#) = happyShift action_27+action_203 (83#) = happyShift action_28+action_203 (85#) = happyShift action_29+action_203 (86#) = happyShift action_30+action_203 (87#) = happyShift action_31+action_203 (6#) = happyGoto action_2+action_203 (7#) = happyGoto action_206+action_203 (9#) = happyGoto action_4+action_203 (16#) = happyGoto action_5+action_203 (17#) = happyGoto action_6+action_203 (18#) = happyGoto action_7+action_203 (21#) = happyGoto action_8+action_203 (24#) = happyGoto action_9+action_203 (25#) = happyGoto action_10+action_203 (26#) = happyGoto action_11+action_203 x = happyTcHack x happyFail++action_204 (41#) = happyShift action_36+action_204 (42#) = happyShift action_37+action_204 (43#) = happyShift action_38+action_204 (44#) = happyShift action_39+action_204 (45#) = happyShift action_40+action_204 (46#) = happyShift action_41+action_204 (47#) = happyShift action_42+action_204 (48#) = happyShift action_43+action_204 (49#) = happyShift action_44+action_204 (50#) = happyShift action_45+action_204 (51#) = happyShift action_46+action_204 (52#) = happyShift action_47+action_204 (53#) = happyShift action_48+action_204 (54#) = happyShift action_49+action_204 (55#) = happyShift action_50+action_204 (56#) = happyShift action_51+action_204 (57#) = happyShift action_52+action_204 (58#) = happyShift action_53+action_204 (59#) = happyShift action_54+action_204 (82#) = happyShift action_205+action_204 x = happyTcHack x happyFail++action_205 (28#) = happyShift action_12+action_205 (29#) = happyShift action_13+action_205 (30#) = happyShift action_14+action_205 (35#) = happyShift action_15+action_205 (42#) = happyShift action_16+action_205 (43#) = happyShift action_17+action_205 (44#) = happyShift action_18+action_205 (50#) = happyShift action_19+action_205 (56#) = happyShift action_20+action_205 (60#) = happyShift action_21+action_205 (61#) = happyShift action_22+action_205 (69#) = happyShift action_23+action_205 (70#) = happyShift action_24+action_205 (74#) = happyShift action_25+action_205 (76#) = happyShift action_26+action_205 (77#) = happyShift action_34+action_205 (81#) = happyShift action_27+action_205 (83#) = happyShift action_28+action_205 (85#) = happyShift action_29+action_205 (86#) = happyShift action_30+action_205 (87#) = happyShift action_31+action_205 (4#) = happyGoto action_210+action_205 (6#) = happyGoto action_2+action_205 (7#) = happyGoto action_33+action_205 (9#) = happyGoto action_4+action_205 (16#) = happyGoto action_5+action_205 (17#) = happyGoto action_6+action_205 (18#) = happyGoto action_7+action_205 (21#) = happyGoto action_8+action_205 (24#) = happyGoto action_9+action_205 (25#) = happyGoto action_10+action_205 (26#) = happyGoto action_11+action_205 x = happyTcHack x happyFail++action_206 (41#) = happyShift action_36+action_206 (42#) = happyShift action_37+action_206 (43#) = happyShift action_38+action_206 (44#) = happyShift action_39+action_206 (45#) = happyShift action_40+action_206 (46#) = happyShift action_41+action_206 (47#) = happyShift action_42+action_206 (48#) = happyShift action_43+action_206 (49#) = happyShift action_44+action_206 (50#) = happyShift action_45+action_206 (51#) = happyShift action_46+action_206 (52#) = happyShift action_47+action_206 (53#) = happyShift action_48+action_206 (54#) = happyShift action_49+action_206 (55#) = happyShift action_50+action_206 (56#) = happyShift action_51+action_206 (57#) = happyShift action_52+action_206 (58#) = happyShift action_53+action_206 (59#) = happyShift action_54+action_206 (82#) = happyShift action_209+action_206 x = happyTcHack x happyFail++action_207 x = happyTcHack x happyReduce_79++action_208 x = happyTcHack x happyReduce_49++action_209 (28#) = happyShift action_12+action_209 (29#) = happyShift action_13+action_209 (30#) = happyShift action_14+action_209 (35#) = happyShift action_15+action_209 (42#) = happyShift action_16+action_209 (43#) = happyShift action_17+action_209 (44#) = happyShift action_18+action_209 (50#) = happyShift action_19+action_209 (56#) = happyShift action_20+action_209 (60#) = happyShift action_21+action_209 (61#) = happyShift action_22+action_209 (69#) = happyShift action_23+action_209 (70#) = happyShift action_24+action_209 (74#) = happyShift action_25+action_209 (76#) = happyShift action_26+action_209 (77#) = happyShift action_34+action_209 (81#) = happyShift action_27+action_209 (83#) = happyShift action_28+action_209 (85#) = happyShift action_29+action_209 (86#) = happyShift action_30+action_209 (87#) = happyShift action_31+action_209 (4#) = happyGoto action_211+action_209 (6#) = happyGoto action_2+action_209 (7#) = happyGoto action_33+action_209 (9#) = happyGoto action_4+action_209 (16#) = happyGoto action_5+action_209 (17#) = happyGoto action_6+action_209 (18#) = happyGoto action_7+action_209 (21#) = happyGoto action_8+action_209 (24#) = happyGoto action_9+action_209 (25#) = happyGoto action_10+action_209 (26#) = happyGoto action_11+action_209 x = happyTcHack x happyFail++action_210 x = happyTcHack x happyReduce_4++action_211 x = happyTcHack x happyReduce_3++happyReduce_1 = happySpecReduce_1 4# happyReduction_1+happyReduction_1 happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn4+ ([happy_var_1]+ )}++happyReduce_2 = happySpecReduce_2 4# happyReduction_2+happyReduction_2 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn4+ ([happy_var_1]+ )}++happyReduce_3 = happyReduce 10# 4# happyReduction_3+happyReduction_3 (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 happyOutTok happy_x_3 of { (QName happy_var_3) -> + case happyOut5 happy_x_5 of { happy_var_5 -> + case happyOut7 happy_x_8 of { happy_var_8 -> + case happyOut4 happy_x_10 of { happy_var_10 -> + happyIn4+ ((Ast "define" ([Avar happy_var_3,happy_var_8]++happy_var_5)):happy_var_10+ ) `HappyStk` happyRest}}}}++happyReduce_4 = happyReduce 9# 4# happyReduction_4+happyReduction_4 (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 happyOutTok happy_x_3 of { (QName happy_var_3) -> + case happyOut7 happy_x_7 of { happy_var_7 -> + case happyOut4 happy_x_9 of { happy_var_9 -> + happyIn4+ ((Ast "define" ([Avar happy_var_3,happy_var_7])):happy_var_9+ ) `HappyStk` happyRest}}}++happyReduce_5 = happySpecReduce_1 5# happyReduction_5+happyReduction_5 happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn5+ ([happy_var_1]+ )}++happyReduce_6 = happySpecReduce_3 5# happyReduction_6+happyReduction_6 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut5 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_3 of { happy_var_3 -> + happyIn5+ (happy_var_1++[happy_var_3]+ )}}++happyReduce_7 = happySpecReduce_1 6# happyReduction_7+happyReduction_7 happy_x_1+ = case happyOutTok happy_x_1 of { (Variable happy_var_1) -> + happyIn6+ (Avar happy_var_1+ )}++happyReduce_8 = happyReduce 5# 7# happyReduction_8+happyReduction_8 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut9 happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_2 of { happy_var_2 -> + case happyOut13 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn7+ ((snd happy_var_3) (happy_var_1 (happy_var_2 ((fst happy_var_3) happy_var_5)))+ ) `HappyStk` happyRest}}}}++happyReduce_9 = happyReduce 4# 7# happyReduction_9+happyReduction_9 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut10 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_4 of { happy_var_4 -> + happyIn7+ (call "some" [happy_var_2 happy_var_4]+ ) `HappyStk` happyRest}}++happyReduce_10 = happyReduce 4# 7# happyReduction_10+happyReduction_10 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut10 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_4 of { happy_var_4 -> + happyIn7+ (call "not" [call "some" [happy_var_2 (call "not" [happy_var_4])]]+ ) `HappyStk` happyRest}}++happyReduce_11 = happyReduce 6# 7# happyReduction_11+happyReduction_11 (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 happyOut7 happy_x_2 of { happy_var_2 -> + case happyOut7 happy_x_4 of { happy_var_4 -> + case happyOut7 happy_x_6 of { happy_var_6 -> + happyIn7+ (call "if" [happy_var_2,happy_var_4,happy_var_6]+ ) `HappyStk` happyRest}}}++happyReduce_12 = happySpecReduce_1 7# happyReduction_12+happyReduction_12 happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++happyReduce_13 = happySpecReduce_1 7# happyReduction_13+happyReduction_13 happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++happyReduce_14 = happySpecReduce_1 7# happyReduction_14+happyReduction_14 happy_x_1+ = case happyOut16 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++happyReduce_15 = happySpecReduce_3 7# happyReduction_15+happyReduction_15 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "to" [happy_var_1,happy_var_3]+ )}}++happyReduce_16 = happySpecReduce_3 7# happyReduction_16+happyReduction_16 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "+" [happy_var_1,happy_var_3]+ )}}++happyReduce_17 = happySpecReduce_3 7# happyReduction_17+happyReduction_17 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "-" [happy_var_1,happy_var_3]+ )}}++happyReduce_18 = happySpecReduce_3 7# happyReduction_18+happyReduction_18 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "*" [happy_var_1,happy_var_3]+ )}}++happyReduce_19 = happySpecReduce_3 7# happyReduction_19+happyReduction_19 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "div" [happy_var_1,happy_var_3]+ )}}++happyReduce_20 = happySpecReduce_3 7# happyReduction_20+happyReduction_20 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "idiv" [happy_var_1,happy_var_3]+ )}}++happyReduce_21 = happySpecReduce_3 7# happyReduction_21+happyReduction_21 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "mod" [happy_var_1,happy_var_3]+ )}}++happyReduce_22 = happySpecReduce_3 7# happyReduction_22+happyReduction_22 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "=" [happy_var_1,happy_var_3]+ )}}++happyReduce_23 = happySpecReduce_3 7# happyReduction_23+happyReduction_23 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "!=" [happy_var_1,happy_var_3]+ )}}++happyReduce_24 = happySpecReduce_3 7# happyReduction_24+happyReduction_24 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "<" [happy_var_1,happy_var_3]+ )}}++happyReduce_25 = happySpecReduce_3 7# happyReduction_25+happyReduction_25 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "<=" [happy_var_1,happy_var_3]+ )}}++happyReduce_26 = happySpecReduce_3 7# happyReduction_26+happyReduction_26 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call ">" [happy_var_1,happy_var_3]+ )}}++happyReduce_27 = happySpecReduce_3 7# happyReduction_27+happyReduction_27 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call ">=" [happy_var_1,happy_var_3]+ )}}++happyReduce_28 = happySpecReduce_3 7# happyReduction_28+happyReduction_28 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "and" [happy_var_1,happy_var_3]+ )}}++happyReduce_29 = happySpecReduce_3 7# happyReduction_29+happyReduction_29 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "or" [happy_var_1,happy_var_3]+ )}}++happyReduce_30 = happySpecReduce_3 7# happyReduction_30+happyReduction_30 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "not" [happy_var_1,happy_var_3]+ )}}++happyReduce_31 = happySpecReduce_3 7# happyReduction_31+happyReduction_31 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "union" [happy_var_1,happy_var_3]+ )}}++happyReduce_32 = happySpecReduce_3 7# happyReduction_32+happyReduction_32 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "itersect" [happy_var_1,happy_var_3]+ )}}++happyReduce_33 = happySpecReduce_3 7# happyReduction_33+happyReduction_33 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "except" [happy_var_1,happy_var_3]+ )}}++happyReduce_34 = happySpecReduce_2 7# happyReduction_34+happyReduction_34 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "uplus" [happy_var_2]+ )}++happyReduce_35 = happySpecReduce_2 7# happyReduction_35+happyReduction_35 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "uminus" [happy_var_2]+ )}++happyReduce_36 = happySpecReduce_2 7# happyReduction_36+happyReduction_36 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "not" [happy_var_2]+ )}++happyReduce_37 = happySpecReduce_1 7# happyReduction_37+happyReduction_37 happy_x_1+ = case happyOutTok happy_x_1 of { (TString happy_var_1) -> + happyIn7+ (Astring happy_var_1+ )}++happyReduce_38 = happySpecReduce_1 7# happyReduction_38+happyReduction_38 happy_x_1+ = case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> + happyIn7+ (Aint happy_var_1+ )}++happyReduce_39 = happySpecReduce_1 7# happyReduction_39+happyReduction_39 happy_x_1+ = case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> + happyIn7+ (Afloat happy_var_1+ )}++happyReduce_40 = happySpecReduce_1 8# happyReduction_40+happyReduction_40 happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn8+ ([happy_var_1]+ )}++happyReduce_41 = happySpecReduce_3 8# happyReduction_41+happyReduction_41 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn8+ (happy_var_1++[happy_var_3]+ )}}++happyReduce_42 = happySpecReduce_2 9# happyReduction_42+happyReduction_42 happy_x_2+ happy_x_1+ = case happyOut10 happy_x_2 of { happy_var_2 -> + happyIn9+ (happy_var_2+ )}++happyReduce_43 = happySpecReduce_2 9# happyReduction_43+happyReduction_43 happy_x_2+ happy_x_1+ = case happyOut11 happy_x_2 of { happy_var_2 -> + happyIn9+ (happy_var_2+ )}++happyReduce_44 = happySpecReduce_3 9# happyReduction_44+happyReduction_44 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut9 happy_x_1 of { happy_var_1 -> + case happyOut10 happy_x_3 of { happy_var_3 -> + happyIn9+ (happy_var_1 . happy_var_3+ )}}++happyReduce_45 = happySpecReduce_3 9# happyReduction_45+happyReduction_45 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut9 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + happyIn9+ (happy_var_1 . happy_var_3+ )}}++happyReduce_46 = happySpecReduce_3 10# happyReduction_46+happyReduction_46 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn10+ (\x -> Ast "for" [happy_var_1,Avar "$",happy_var_3,x]+ )}}++happyReduce_47 = happyReduce 5# 10# happyReduction_47+happyReduction_47 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut6 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut6 happy_x_5 of { happy_var_5 -> + happyIn10+ (\x -> Ast "for" [happy_var_1,happy_var_5,happy_var_3,x]+ ) `HappyStk` happyRest}}}++happyReduce_48 = happyReduce 5# 10# happyReduction_48+happyReduction_48 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut10 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn10+ (\x -> happy_var_1(Ast "for" [happy_var_3,Avar "$",happy_var_5,x])+ ) `HappyStk` happyRest}}}++happyReduce_49 = happyReduce 7# 10# happyReduction_49+happyReduction_49 (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 happyOut10 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + case happyOut6 happy_x_7 of { happy_var_7 -> + happyIn10+ (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_7,happy_var_5,x])+ ) `HappyStk` happyRest}}}}++happyReduce_50 = happySpecReduce_3 11# happyReduction_50+happyReduction_50 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn11+ (\x -> Ast "let" [happy_var_1,happy_var_3,x]+ )}}++happyReduce_51 = happyReduce 5# 11# happyReduction_51+happyReduction_51 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut6 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn11+ (\x -> happy_var_1(Ast "let" [happy_var_3,happy_var_5,x])+ ) `HappyStk` happyRest}}}++happyReduce_52 = happySpecReduce_2 12# happyReduction_52+happyReduction_52 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn12+ (\x -> Ast "predicate" [happy_var_2,x]+ )}++happyReduce_53 = happySpecReduce_0 12# happyReduction_53+happyReduction_53 = happyIn12+ (id+ )++happyReduce_54 = happySpecReduce_2 13# happyReduction_54+happyReduction_54 happy_x_2+ happy_x_1+ = case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn13+ ((\x -> Ast "sortTuple" (x:(fst happy_var_2)),+ \x -> Ast "sort" (x:(snd happy_var_2)))+ )}++happyReduce_55 = happySpecReduce_0 13# happyReduction_55+happyReduction_55 = happyIn13+ ((id,id)+ )++happyReduce_56 = happySpecReduce_2 14# happyReduction_56+happyReduction_56 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + happyIn14+ (([happy_var_1],[happy_var_2])+ )}}++happyReduce_57 = happyReduce 4# 14# happyReduction_57+happyReduction_57 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut14 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut15 happy_x_4 of { happy_var_4 -> + happyIn14+ (((fst happy_var_1)++[happy_var_3],(snd happy_var_1)++[happy_var_4])+ ) `HappyStk` happyRest}}}++happyReduce_58 = happySpecReduce_1 15# happyReduction_58+happyReduction_58 happy_x_1+ = happyIn15+ (Avar "ascending"+ )++happyReduce_59 = happySpecReduce_1 15# happyReduction_59+happyReduction_59 happy_x_1+ = happyIn15+ (Avar "descending"+ )++happyReduce_60 = happySpecReduce_0 15# happyReduction_60+happyReduction_60 = happyIn15+ (Avar "ascending"+ )++happyReduce_61 = happyReduce 4# 16# happyReduction_61+happyReduction_61 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_3 of { (QName happy_var_3) -> + happyIn16+ (call "element" [Avar happy_var_3]+ ) `HappyStk` happyRest}++happyReduce_62 = happyReduce 4# 16# happyReduction_62+happyReduction_62 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_3 of { (QName happy_var_3) -> + happyIn16+ (call "attribute" [Avar happy_var_3]+ ) `HappyStk` happyRest}++happyReduce_63 = happyReduce 6# 17# happyReduction_63+happyReduction_63 (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 happyOut18 happy_x_1 of { happy_var_1 -> + case happyOut19 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_5 of { (QName happy_var_5) -> + happyIn17+ (if head happy_var_1 == Astring happy_var_5+ then Ast "construction" (happy_var_1++[concatAll happy_var_3])+ else error("Unmatched tags in element construction: "++happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_64 = happyReduce 5# 17# happyReduction_64+happyReduction_64 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_4 of { (QName happy_var_4) -> + happyIn17+ (if head happy_var_1 == Astring happy_var_4+ then Ast "construction" (happy_var_1++[call "empty" []])+ else error("Unmatched tags in element construction: "++happy_var_4)+ ) `HappyStk` happyRest}}++happyReduce_65 = happySpecReduce_2 17# happyReduction_65+happyReduction_65 happy_x_2+ happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + happyIn17+ (Ast "construction" (happy_var_1++[call "empty" []])+ )}++happyReduce_66 = happySpecReduce_2 18# happyReduction_66+happyReduction_66 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { (QName happy_var_2) -> + happyIn18+ ([Astring happy_var_2,Ast "attributes" []]+ )}++happyReduce_67 = happySpecReduce_3 18# happyReduction_67+happyReduction_67 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { (QName happy_var_2) -> + case happyOut20 happy_x_3 of { happy_var_3 -> + happyIn18+ ([Astring happy_var_2,Ast "attributes" happy_var_3]+ )}}++happyReduce_68 = happySpecReduce_3 19# happyReduction_68+happyReduction_68 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn19+ (happy_var_2+ )}++happyReduce_69 = happySpecReduce_1 19# happyReduction_69+happyReduction_69 happy_x_1+ = case happyOutTok happy_x_1 of { (TString happy_var_1) -> + happyIn19+ ([Astring happy_var_1]+ )}++happyReduce_70 = happySpecReduce_1 19# happyReduction_70+happyReduction_70 happy_x_1+ = case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> + happyIn19+ ([Astring happy_var_1]+ )}++happyReduce_71 = happySpecReduce_1 19# happyReduction_71+happyReduction_71 happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn19+ ([happy_var_1]+ )}++happyReduce_72 = happyReduce 4# 19# happyReduction_72+happyReduction_72 (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 happyOut8 happy_x_3 of { happy_var_3 -> + happyIn19+ (happy_var_1++happy_var_3+ ) `HappyStk` happyRest}}++happyReduce_73 = happySpecReduce_2 19# happyReduction_73+happyReduction_73 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (TString happy_var_2) -> + happyIn19+ (happy_var_1++[Astring happy_var_2]+ )}}++happyReduce_74 = happySpecReduce_2 19# happyReduction_74+happyReduction_74 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (XMLtext happy_var_2) -> + happyIn19+ (happy_var_1++[Astring happy_var_2]+ )}}++happyReduce_75 = happySpecReduce_2 19# happyReduction_75+happyReduction_75 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut17 happy_x_2 of { happy_var_2 -> + happyIn19+ (happy_var_1++[happy_var_2]+ )}}++happyReduce_76 = happySpecReduce_3 20# happyReduction_76+happyReduction_76 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + case happyOutTok happy_x_3 of { (TString happy_var_3) -> + happyIn20+ ([Ast "pair" [Astring happy_var_1,Astring happy_var_3]]+ )}}++happyReduce_77 = happyReduce 5# 20# happyReduction_77+happyReduction_77 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + case happyOut7 happy_x_4 of { happy_var_4 -> + happyIn20+ ([Ast "pair" [Astring happy_var_1,happy_var_4]]+ ) `HappyStk` happyRest}}++happyReduce_78 = happyReduce 4# 20# happyReduction_78+happyReduction_78 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (QName happy_var_2) -> + case happyOutTok happy_x_4 of { (TString happy_var_4) -> + happyIn20+ ((Ast "pair" [Astring happy_var_2,Astring happy_var_4]):happy_var_1+ ) `HappyStk` happyRest}}}++happyReduce_79 = happyReduce 6# 20# happyReduction_79+happyReduction_79 (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 happyOut20 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (QName happy_var_2) -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn20+ ((Ast "pair" [Astring happy_var_2,happy_var_5]):happy_var_1+ ) `HappyStk` happyRest}}}++happyReduce_80 = happySpecReduce_1 21# happyReduction_80+happyReduction_80 happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn21+ (happy_var_1 "child" (Avar ".")+ )}++happyReduce_81 = happySpecReduce_2 21# happyReduction_81+happyReduction_81 happy_x_2+ happy_x_1+ = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn21+ (happy_var_2 "attribute" (Avar ".")+ )}++happyReduce_82 = happySpecReduce_2 21# happyReduction_82+happyReduction_82 happy_x_2+ happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn21+ (happy_var_2(happy_var_1 "child" (Avar "."))+ )}}++happyReduce_83 = happySpecReduce_3 21# happyReduction_83+happyReduction_83 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_2 of { happy_var_2 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn21+ (happy_var_3(happy_var_2 "attribute" (Avar "."))+ )}}++happyReduce_84 = happySpecReduce_1 22# happyReduction_84+happyReduction_84 happy_x_1+ = case happyOut23 happy_x_1 of { happy_var_1 -> + happyIn22+ (happy_var_1+ )}++happyReduce_85 = happySpecReduce_2 22# happyReduction_85+happyReduction_85 happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (happy_var_2 . happy_var_1+ )}}++happyReduce_86 = happySpecReduce_2 23# happyReduction_86+happyReduction_86 happy_x_2+ happy_x_1+ = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn23+ (\e -> happy_var_2 "child" e+ )}++happyReduce_87 = happySpecReduce_3 23# happyReduction_87+happyReduction_87 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23+ (\e -> happy_var_3 "attribute" e+ )}++happyReduce_88 = happySpecReduce_3 23# happyReduction_88+happyReduction_88 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23+ (\e -> happy_var_3 "descendant" e+ )}++happyReduce_89 = happyReduce 4# 23# happyReduction_89+happyReduction_89 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut24 happy_x_4 of { happy_var_4 -> + happyIn23+ (\e -> happy_var_4 "descendant_attribute" e+ ) `HappyStk` happyRest}++happyReduce_90 = happySpecReduce_2 23# happyReduction_90+happyReduction_90 happy_x_2+ happy_x_1+ = happyIn23+ (\e -> call "parent" [e]+ )++happyReduce_91 = happySpecReduce_1 24# happyReduction_91+happyReduction_91 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn24+ (happy_var_1+ )}++happyReduce_92 = happyReduce 4# 24# happyReduction_92+happyReduction_92 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_3 of { happy_var_3 -> + happyIn24+ (\t e -> Ast "predicate" [happy_var_3,happy_var_1 t e]+ ) `HappyStk` happyRest}}++happyReduce_93 = happySpecReduce_1 25# happyReduction_93+happyReduction_93 happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn25+ (\t e -> happy_var_1 t e+ )}++happyReduce_94 = happySpecReduce_1 25# happyReduction_94+happyReduction_94 happy_x_1+ = happyIn25+ (\t e -> call t [Astring "*",e]+ )++happyReduce_95 = happySpecReduce_1 25# happyReduction_95+happyReduction_95 happy_x_1+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + happyIn25+ (\t e -> call t [Astring happy_var_1,e]+ )}++happyReduce_96 = happySpecReduce_1 26# happyReduction_96+happyReduction_96 happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn26+ (\_ _ -> happy_var_1+ )}++happyReduce_97 = happySpecReduce_1 26# happyReduction_97+happyReduction_97 happy_x_1+ = happyIn26+ (\_ e -> e+ )++happyReduce_98 = happySpecReduce_3 26# happyReduction_98+happyReduction_98 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn26+ (\_ _ -> concatAll happy_var_2+ )}++happyReduce_99 = happySpecReduce_2 26# happyReduction_99+happyReduction_99 happy_x_2+ happy_x_1+ = happyIn26+ (\_ _ -> call "empty" []+ )++happyReduce_100 = happyReduce 4# 26# happyReduction_100+happyReduction_100 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + case happyOut8 happy_x_3 of { happy_var_3 -> + happyIn26+ (\_ _ -> call happy_var_1 happy_var_3+ ) `HappyStk` happyRest}}++happyReduce_101 = happySpecReduce_3 26# happyReduction_101+happyReduction_101 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + happyIn26+ (if elem happy_var_1 ["text"]+ then \_ e -> call happy_var_1 [e]+ else \_ _ -> call happy_var_1 []+ )}++happyNewToken action sts stk [] =+ action 88# 88# notHappyAtAll (HappyState action) sts stk []++happyNewToken action sts stk (tk:tks) =+ let cont i = action i i tk (HappyState action) sts stk tks in+ case tk of {+ RETURN -> cont 27#;+ SOME -> cont 28#;+ EVERY -> cont 29#;+ IF -> cont 30#;+ THEN -> cont 31#;+ ELSE -> cont 32#;+ LB -> cont 33#;+ RB -> cont 34#;+ LP -> cont 35#;+ RP -> cont 36#;+ LSB -> cont 37#;+ RSB -> cont 38#;+ LESCAPE -> cont 39#;+ RESCAPE -> cont 40#;+ TO -> cont 41#;+ PLUS -> cont 42#;+ MINUS -> cont 43#;+ TIMES -> cont 44#;+ DIV -> cont 45#;+ IDIV -> cont 46#;+ MOD -> cont 47#;+ TEQ -> cont 48#;+ TNEQ -> cont 49#;+ TLT -> cont 50#;+ LEQ -> cont 51#;+ TGT -> cont 52#;+ GEQ -> cont 53#;+ AND -> cont 54#;+ OR -> cont 55#;+ NOT -> cont 56#;+ UNION -> cont 57#;+ INTERSECT -> cont 58#;+ EXCEPT -> cont 59#;+ FOR -> cont 60#;+ LET -> cont 61#;+ IN -> cont 62#;+ COMMA -> cont 63#;+ ASSIGN -> cont 64#;+ WHERE -> cont 65#;+ ORDERBY -> cont 66#;+ ASCENDING -> cont 67#;+ DESCENDING -> cont 68#;+ ELEMENT -> cont 69#;+ ATTRIBUTE -> cont 70#;+ STAG -> cont 71#;+ ETAG -> cont 72#;+ SATISFIES -> cont 73#;+ ATSIGN -> cont 74#;+ SLASH -> cont 75#;+ QName happy_dollar_dollar -> cont 76#;+ DEFINE -> cont 77#;+ FUNCTION -> cont 78#;+ AT -> cont 79#;+ DOTS -> cont 80#;+ DOT -> cont 81#;+ SEMI -> cont 82#;+ Variable happy_dollar_dollar -> cont 83#;+ XMLtext happy_dollar_dollar -> cont 84#;+ TInteger happy_dollar_dollar -> cont 85#;+ TFloat happy_dollar_dollar -> cont 86#;+ TString happy_dollar_dollar -> cont 87#;+ _ -> 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 . parseError++parse tks = happyRunIdentity happySomeParser where+ happySomeParser = happyThen (happyParse action_0 tks) (\x -> happyReturn (happyOut4 x))++happySeq = happyDontSeq+++-- Abstract Syntax Tree for XQueries+data Ast = Ast String [Ast]+ | Avar String+ | Aint Int+ | Afloat Float+ | Astring String+ deriving Eq+++instance Show Ast+ where show (Ast s []) = s ++ "()"+ show (Ast s (x:xs)) = s ++ "(" ++ (show x)+ ++ (foldr (\a r -> ","++(show a)++r) "" xs)+ ++ ")"+ show (Avar s) = s+ show (Aint n) = show n+ show (Afloat n) = show n+ show (Astring s) = "\'" ++ s ++ "\'"+++call :: String -> [Ast] -> Ast+call name args = Ast "call" ((Avar name):args)+++concatAll :: [Ast] -> Ast+concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs+concatAll _ = call "empty" []+++parseError tk = error ("Parse error: "++(show (take 10 tk)))+++data Token+ = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB+ | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD+ | TEQ | TNEQ | TLT | LEQ | TGT | GEQ | AND | OR | NOT | UNION | INTERSECT+ | EXCEPT | FOR | LET | IN | COMMA | ASSIGN | WHERE | ORDERBY | ASCENDING+ | DESCENDING | ELEMENT | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN+ | SLASH | DEFINE | FUNCTION | AT | SEMI | DOT | DOTS | TokenEOF+ | QName String | Variable String | XMLtext String | TInteger Int+ | TFloat Float | TString String+ deriving Show+++scan :: String -> [Token]+scan cs = lexer cs [0]+++xmlText "" = []+xmlText text = [XMLtext text]++-- scans XML PCDATA and returns an XMLtext token with the PCData text+xml :: String -> String -> [Int] -> [Token]+xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n))+xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n)+xml ('<':cs) text (k:n) = (xmlText text)++(TLT : lexer cs (k+2:n))+xml ('\'':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)+xml (c:cs) text n = xml cs (text++[c]) n+xml [] text _ = xmlText text+++isQN c = elem c "_:-" || isDigit c || isAlpha c++isVar c = elem c "_" || isDigit c || isAlpha c++-- the XQuery scanner+lexer :: String -> [Int] -> [Token]+lexer [] [0] = []+lexer [] _ = error("Unbalanced tags")+lexer (' ':'>':' ':cs) n = TGT : lexer cs n+lexer (c:cs) n+ | isSpace c = lexer cs n+ | isAlpha c = lexVar (c:cs) n+ | isDigit c = lexNum (c:cs) n+lexer ('$':c:cs) n | isAlpha c+ = let (var,rest) = span isVar (c:cs)+ in (Variable var) : lexer rest n+lexer ('\'':'{':cs) n = LESCAPE : lexer cs n+lexer (':':'=':cs) n = ASSIGN : lexer cs n+lexer ('<':'/':cs) n = STAG : lexer cs n+lexer ('<':'=':cs) n = LEQ : lexer cs n+lexer ('>':'=':cs) n = GEQ : lexer cs n+lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)+lexer ('.':'.':cs) n = DOTS : lexer cs n+lexer ('.':cs) n = DOT : lexer cs n+lexer ('}':'\'':cs) n = RESCAPE : lexer cs n+lexer ('!':'=':cs) n = TNEQ : lexer cs n+lexer ('\'':cs) n = lexString cs n+lexer ('[':cs) n = LB : lexer cs n+lexer (']':cs) n = RB : lexer cs n+lexer ('(':cs) n = LP : lexer cs n+lexer (')':cs) n = RP : lexer cs n+lexer ('}':cs) (_:n) = RSB : xml cs "" n+lexer ('+':cs) n = PLUS : lexer cs n+lexer ('-':cs) n = MINUS : lexer cs n+lexer ('*':cs) n = TIMES : lexer cs n+lexer ('=':cs) n = TEQ : lexer cs n+lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n+lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n)+lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (k-1:n) else xml cs "" (k-1:n))+lexer (',':cs) n = COMMA : lexer cs n+lexer ('@':cs) n = ATSIGN : lexer cs n+lexer ('/':cs) n = SLASH : lexer cs n+lexer ('{':cs) n = LSB : lexer cs n+lexer (';':cs) n = SEMI : lexer cs n lexer (c:cs) n = error ("illegal character "++[c]) lexNum cs n = if null rest || head rest /= '.'
XQueryParser.y view
@@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/-- Creation: 02/15/08, last update: 03/18/08+- Creation: 02/15/08, last update: 03/23/08 - - Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved. - This material is provided as is, with absolutely no warranty expressed or implied.@@ -73,9 +73,12 @@ '@' { ATSIGN } '/' { SLASH } 'QName' { QName $$ }+ 'define' { DEFINE }+ 'function' { FUNCTION } 'at' { AT } '..' { DOTS } '.' { DOT }+ ';' { SEMI } 'Variable' { Variable $$ } 'XMLtext' { XMLtext $$ } 'Integer' { TInteger $$ }@@ -97,8 +100,15 @@ %%+prog : expr { [$1] }+ | expr 'XMLtext' { [$1] }+ | 'define' 'function' 'QName'+ '(' params ')' '=' expr ';' prog { (Ast "define" ([Avar $3,$8]++$5)):$10 }+ | 'define' 'function' 'QName'+ '(' ')' '=' expr ';' prog { (Ast "define" ([Avar $3,$7])):$9 } -prog : expr { $1 }+params : var { [$1] }+ | params ',' var { $1++[$3] } var : 'Variable' { Avar $1 } @@ -271,7 +281,7 @@ | TEQ | TNEQ | TLT | LEQ | TGT | GEQ | AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA | ASSIGN | WHERE | ORDERBY | ASCENDING | DESCENDING | ELEMENT | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN- | SLASH | DEFINE | FUNCTION | AT | DOT | DOTS | TokenEOF+ | SLASH | DEFINE | FUNCTION | AT | SEMI | DOT | DOTS | TokenEOF | QName String | Variable String | XMLtext String | TInteger Int | TFloat Float | TString String deriving Show@@ -337,6 +347,7 @@ lexer ('@':cs) n = ATSIGN : lexer cs n lexer ('/':cs) n = SLASH : lexer cs n lexer ('{':cs) n = LSB : lexer cs n+lexer (';':cs) n = SEMI : lexer cs n lexer (c:cs) n = error ("illegal character "++[c]) lexNum cs n = if null rest || head rest /= '.'
+ data/q1.xq view
@@ -0,0 +1,8 @@+define function f ( $x, $y ) = <student>{$x,' ',$y}</student>;++<students>{+ for $s in doc('data/cs.xml')//gradstudent+ orderby $s/gpa descending, $s//lastname+ return f( $s/name, $s/gpa/text() )+}</students>+
index.html view
@@ -37,7 +37,7 @@ <pre> yum install ghc happy </pre>-Then download <a href="/HXQ-0.3.tar.gz">HXQ</a> and untar it.+Then download <a href="/HXQ-0.4.tar.gz">HXQ</a> and untar it. You can either use cabal or make to build it. Then run xquery to test drive it. <p> <h2>Current Status</h2>@@ -48,7 +48,7 @@ checked against the current node position. The most important omission is backward step axes, such as /.. (parent). Some, but not all, parent axis steps are removed using optimization rules, all others cause a compilation error. <p>-<h2>Use</h2>+<h2>Using the Compiler</h2> <p> HXQ represents XML data as rose trees: <pre>@@ -71,7 +71,8 @@ </ul> where <tt>query</tt> is a string value (a Haskell expression that evaluates to a string <b>at compile-time</b>), They both translate the query into Haskell-code, which is compiled and optimized into machine code directly. The code that xe generates has type <tt>XSeq</tt> (a sequence of XML trees)+code, which is compiled and optimized into machine code directly.+The code that xe generates has type <tt>XSeq</tt> (a sequence of XML trees) while the code that xq generates has type <tt>(IO XSeq)</tt>. If the query reads at least one document (using doc(...)), then you should use xq since it requires IO. To define constant XML data or a function body, it is better to use xe.@@ -96,15 +97,31 @@ b <- $(xq " f( $a/paper[10], $a/paper[8] ) ") putStrLn (show b) </pre>-Another example, can be found in <a href="Main.hs">Main.hs</a>.+Another example, can be found in <a href="Test1.hs">Test1.hs</a>. <p>+<h2>Using the Interpreter</h2>+<p>+The HXQ interpreter is far more slower than the compiler; use it only if you need to evaluate ad-hoc XQueries read from input or from files.+The main functions are:+<ul>+<li> <tt>xquery :: String -> IO XSeq</tt> -- Evaluates an XQuery in a string+<li> <tt>xfile :: String -> IO XSeq</tt> -- Evaluates an XQuery in a file+</ul>+The HXQ interpreter doesn't recognize Haskell variables and functions. The main HXQ program, called <tt>xquery</tt>,+evaluates an XQuery in a file using the interpreter. For example:+<pre>+xquery data/q1.xq+</pre> +Without an argument, it reads the XQuery from input.+<p>+<h2>Extending HXQ</h2>+<p> If you want to extend HXQ, you need to read about <a href="http://www.haskell.org/bz/thdoc.htm">Template Haskell</a>.-Use <tt>make test</tt> to do various translation tests in ghci. You can look at the+Use <tt>make ghci</tt> to do various translation tests in ghci. You can look at the Abstract Syntax Trees and the generated code from a query by evaluating-<tt>cq query</tt>. Basically, the way you generate Haskell code is-similar to operational semantics (where [| ... |] are syntactic brackets).+<tt>cq query</tt>. </body> <p> <hr> <p>-<address>Last modified: 03/21/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>+<address>Last modified: 03/23/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>