diff --git a/HXQ.cabal b/HXQ.cabal --- a/HXQ.cabal +++ b/HXQ.cabal @@ -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 diff --git a/Main.hs b/Main.hs --- a/Main.hs +++ b/Main.hs @@ -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 "{$s//firstname/text(),' ',$s//lastname/text()}") - -main = do a <- $(xq (" for $s in doc('data/cs.xml')//gradstudent " - ++" orderby $s/gpa descending, $s//lastname " - ++" return {$s//firstname/text(),' ', " - ++" $s//lastname/text(),' ', " - ++" $s/gpa/text()} ")) - 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 (" { " - ++" let $d := doc('data/cs.xml') " - ++" for $s in $d//gradstudent " - ++" where $s/gpa = '4.0' " - ++" return f($d//deptname,$s) " - ++" } ")) - 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) diff --git a/Main2.hs b/Main2.hs deleted file mode 100644 --- a/Main2.hs +++ /dev/null @@ -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 "{$x,', ',$y}") - -main = do a <- $(xq ("{ " - ++" for $x in doc('/home/fegaras/data/dblp.xml')//inproceedings at $i " - ++" where $x/author = 'Leonidas Fegaras' " - ++" orderby $x/year descending " - ++" return { $i, ') ', $x/booktitle/text(), " - ++" ': ', $x/title/text() " - ++" } " - ++" } ")) - putStrLn (show a) - b <- $(xq "f($a/paper[10],$a/paper[8])") - putStrLn (show b) - diff --git a/Makefile b/Makefile --- a/Makefile +++ b/Makefile @@ -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 diff --git a/Test1.hs b/Test1.hs new file mode 100644 --- /dev/null +++ b/Test1.hs @@ -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 "{$s//firstname/text(),' ',$s//lastname/text()}") + +main = do a <- $(xq (" for $s in doc('data/cs.xml')//gradstudent " + ++" orderby $s/gpa descending, $s//lastname " + ++" return {$s//firstname/text(),' ', " + ++" $s//lastname/text(),' ', " + ++" $s/gpa/text()} ")) + 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 (" { " + ++" let $d := doc('data/cs.xml') " + ++" for $s in $d//gradstudent " + ++" where $s/gpa = '4.0' " + ++" return f($d//deptname,$s) " + ++" } ")) + 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) + diff --git a/Test2.hs b/Test2.hs new file mode 100644 --- /dev/null +++ b/Test2.hs @@ -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 "{$x,', ',$y}") + +main = do a <- $(xq ("{ " + ++" for $x in doc('/home/fegaras/data/dblp.xml')//inproceedings at $i " + ++" where $x/author = 'Leonidas Fegaras' " + ++" orderby $x/year descending " + ++" return { $i, ') ', $x/booktitle/text(), " + ++" ': ', $x/title/text() " + ++" } " + ++" } ")) + putStrLn (show a) + b <- $(xq "f($a/paper[10],$a/paper[8])") + putStrLn (show b) + diff --git a/XQuery.hs b/XQuery.hs --- a/XQuery.hs +++ b/XQuery.hs @@ -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)++"" -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)) [| [] |] diff --git a/XQueryCompiler.hs b/XQueryCompiler.hs new file mode 100644 --- /dev/null +++ b/XQueryCompiler.hs @@ -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)++"" +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))) [| [] |] + diff --git a/XQueryInterpreter.hs b/XQueryInterpreter.hs new file mode 100644 --- /dev/null +++ b/XQueryInterpreter.hs @@ -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 + diff --git a/XQueryParser.hs b/XQueryParser.hs --- a/XQueryParser.hs +++ b/XQueryParser.hs @@ -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 /= '.' diff --git a/XQueryParser.y b/XQueryParser.y --- a/XQueryParser.y +++ b/XQueryParser.y @@ -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 /= '.' diff --git a/data/q1.xq b/data/q1.xq new file mode 100644 --- /dev/null +++ b/data/q1.xq @@ -0,0 +1,8 @@ +define function f ( $x, $y ) = {$x,' ',$y}; + +{ + for $s in doc('data/cs.xml')//gradstudent + orderby $s/gpa descending, $s//lastname + return f( $s/name, $s/gpa/text() ) +} + diff --git a/index.html b/index.html --- a/index.html +++ b/index.html @@ -37,7 +37,7 @@ 
 yum install ghc happy
-Then download HXQ and untar it. +Then download HXQ and untar it. You can either use cabal or make to build it. Then run xquery to test drive it.

Current Status

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

-

Use

+

Using the Compiler

HXQ represents XML data as rose trees: 

@@ -71,7 +71,8 @@
 
 where query is a string value (a Haskell expression that evaluates
 to a string at compile-time), They both translate the query into Haskell
-code, which is compiled and optimized into machine code directly. The code that xe generates has type XSeq (a sequence of XML trees)
+code, which is compiled and optimized into machine code directly.
+The code that xe generates has type XSeq (a sequence of XML trees)
 while the code that xq generates has type (IO XSeq). 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)
-Another example, can be found in Main.hs. +Another example, can be found in Test1.hs.

+

Using the Interpreter

+

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

+The HXQ interpreter doesn't recognize Haskell variables and functions. The main HXQ program, called xquery, +evaluates an XQuery in a file using the interpreter. For example: +
+xquery data/q1.xq
+
+Without an argument, it reads the XQuery from input. +

+

Extending HXQ

+

If you want to extend HXQ, you need to read about Template Haskell. -Use make test to do various translation tests in ghci. You can look at the +Use make ghci to do various translation tests in ghci. You can look at the Abstract Syntax Trees and the generated code from a query by evaluating -cq query. Basically, the way you generate Haskell code is -similar to operational semantics (where [| ... |] are syntactic brackets). +cq query.

-

Last modified: 03/21/08 by Leonidas Fegaras
+
Last modified: 03/23/08 by Leonidas Fegaras