HXQ 0.5 → 0.6
raw patch · 12 files changed
+6263/−4772 lines, 12 files
Files
- HXQ.cabal +1/−1
- Main.hs +14/−10
- Makefile +7/−11
- Test1.hs +8/−9
- Test2.hs +4/−3
- XQuery.hs +0/−1
- XQueryCompiler.hs +339/−194
- XQueryInterpreter.hs +102/−64
- XQueryParser.hs +5626/−4383
- XQueryParser.y +121/−54
- data/q1.xq +12/−3
- index.html +29/−39
HXQ.cabal view
@@ -1,5 +1,5 @@ Name: HXQ-Version: 0.5+Version: 0.6 Description: A Compiler from XQuery to Haskell Synopsis: A Compiler from XQuery to Haskell Category: XML
Main.hs view
@@ -2,7 +2,7 @@ - - The main program of the XQuery interpreter - Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)-- Date: 03/23/2008+- Date: 03/30/2008 - ---------------------------------------------------------------} @@ -11,15 +11,19 @@ module Main where import System.Environment+import XQueryCompiler(functions) import XQuery -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) +main = do env <- getArgs+ putStrLn "HXQ: XQuery Interpreter version 0.6"+ if (length env) == 1 && (head env) == "-help"+ then putStrLn ("Functions: "++(foldr (\(f,_,_) r -> f++" "++r) "" functions))+ else do 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)
Makefile view
@@ -1,5 +1,5 @@ hxml = hxml-0.2-options = -O+options = -O2 xquery: XQueryParser.hs XQueryCompiler.hs XQueryInterpreter.hs XQuery.hs Main.hs ghc $(options) -i$(hxml) --make Main.hs -o xquery@@ -7,19 +7,16 @@ XQueryParser.hs: XQueryParser.y happy -g -c XQueryParser.y -run: xquery- ./xquery--test1: xquery- ghc -O -ihxml-0.2 --make Test1.hs -o test1+test1: XQueryParser.hs+ ghc $(options) -i$(hxml) --make Test1.hs -o test1 ./test1 -test2: xquery- ghc -O -ihxml-0.2 --make Test2.hs -o test2- ./test2+test2: XQueryParser.hs+ ghc $(options) -i$(hxml) --make Test2.hs -o test2+ time ./test2 +RTS -H128m ghci: XQueryParser.hs- ghci -fth -i$(hxml) XQuery.hs XQueryCompiler.hs XQueryInterpreter.hs XQueryParser.hs+ ghci -fth -i$(hxml) XQuery.hs cabal: clean XQueryParser.hs runhaskell Setup.lhs configure --prefix=$HOME@@ -28,4 +25,3 @@ clean: /bin/rm -f *~ *.o *.hi $(hxml)/*.o $(hxml)/*.hi XQueryParser.hs *.stat *.prof *.ps *.aux *.hp xquery test1 test2-
Test1.hs view
@@ -1,8 +1,8 @@ {-------------------------------------------------------------- --- The main program of the XQuery processor+- A main program to test the XQuery processor - Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)-- Date: 03/19/2008+- Date: 03/30/2008 - ---------------------------------------------------------------} @@ -22,21 +22,20 @@ ++" $s/gpa/text()}</student> ")) putStrLn (show a) let query name = $(xq " doc('data/cs.xml')//gradstudent[.//lastname = $name]//firstname ")- b <- query $(xe " 'Galanis' ") -- or use: query [XText "Galanis"]+ b <- query $(xe " 'Galanis' ") putStrLn (show b) c <- $(xq (" <good-students>{ " ++" let $d := doc('data/cs.xml') " ++" for $s in $d//gradstudent "- ++" where $s/gpa = '4.0' "+ ++" where $s/gpa = 4.0 " ++" return f($d//deptname,$s) " ++" }</good-students> ")) putStrLn (show c) let q file = $(xq (" let $d := doc($file)//gradstudent "- ++" return ($d/../deptname,count($d)) "))- d <- q $(xe "'data/cs.xml'")+ ++" 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+ iquery <- getLine -- read an XQuery from input+ e <- xquery iquery -- evaluate it using the XQuery interpreter putStrLn (show e)-
Test2.hs view
@@ -1,8 +1,9 @@ {-------------------------------------------------------------- --- The main program of the XQuery processor+- Testing the XQuery compiler on a large file+- Download dblp.xml from http://dblp.uni-trier.de/xml/ - Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)-- Date: 03/19/2008+- Date: 03/30/2008 - ---------------------------------------------------------------} @@ -12,6 +13,7 @@ import XQuery + f(x,y) = $(xe "<a>{$x,', ',$y}</a>") main = do a <- $(xq ("<result>{ "@@ -25,4 +27,3 @@ putStrLn (show a) b <- $(xq "f($a/paper[10],$a/paper[8])") putStrLn (show b)-
XQuery.hs view
@@ -22,4 +22,3 @@ import XQueryCompiler import XQueryInterpreter-
XQueryCompiler.hs view
@@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/-- Creation: 02/15/08, last update: 03/25/08+- Creation: 02/15/08, last update: 03/30/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.@@ -14,7 +14,7 @@ --------------------------------------------------------------------------------------} -{-# OPTIONS_GHC -fth #-}+{-# OPTIONS_GHC -fth -funbox-strict-fields #-} module XQueryCompiler where @@ -25,17 +25,20 @@ 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+data XTree = XElem Tag AttList !Int [XTree] -- Int is the preorder numbering for document order+ | XText String+ | XInt !Int+ | XFloat !Float+ | XBool !Bool+ deriving Eq type XSeq = [XTree] @@ -44,10 +47,12 @@ showAL = foldr(\(a,v) r -> " "++a++"=\""++v++"\""++r) [] showXT :: XTree -> Bool -> String-showXT (XElem tag al xs) pad = "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">"+showXT (XElem tag al _ []) pad = "<"++tag++(showAL al)++"/>"+showXT (XElem tag al _ xs) pad = "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">" showXT (XText text) pad = text showXT (XInt n) pad = (if pad then " " else "")++(show n) showXT (XFloat n) pad = (if pad then " " else "")++(show n)+showXT (XBool v) pad = (if pad then " " else "")++(if v then "true" else "false") showXS :: XSeq -> String showXS [] = ""@@ -59,74 +64,96 @@ -- 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'')+materialize stream = XElem "root" [] 1 [head (filter (\x -> case x of XElem _ _ _ _ -> True; _ -> False)+ ((\(x,_,_)->x) (ml stream 2)))]+ where m ((TextEvent t):xs) i = (XText t,xs,i)+ m ((EmptyEvent n atts):xs) i = (XElem n atts i [],xs,i+1)+ m ((StartEvent n atts):xs) i = let (el,xs',i') = ml xs (i+1)+ in (XElem n atts i el,xs',i')+ m (_:xs) i = (XText "unrecognized",xs,i)+ m [] i = (XText "unrecognized",[],i)+ ml ((EndEvent n):xs) i = ([],xs,i)+ ml xs i = let (e,xs',i') = m xs i+ (el,xs'',i'') = ml xs' i'+ in (e:el,xs'',i'') {--------------- 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- _ -> []+child_step :: Tag -> XTree -> XSeq+child_step 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:(concatMap (descendant m) cs)-descendant m (XElem t al cs) = concatMap (descendant m) cs-descendant m _ = []+descendant_step :: Tag -> XTree -> XSeq+descendant_step m (x@(XElem t _ _ cs))+ | m==t || m=="*"+ = x:(concatMap (descendant_step m) cs)+descendant_step m (XElem t _ _ cs) = concatMap (descendant_step m) cs+descendant_step 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- _ -> []+attribute_step :: Tag -> XTree -> XSeq+attribute_step 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)- (concatMap (attributeDescendant m) cs) al-attributeDescendant m _ = []+attribute_descendant_step :: Tag -> XTree -> XSeq+attribute_descendant_step m (x@(XElem _ al _ cs))+ = foldr (\(k,v) s -> if k==m || m=="*"+ then (XText v):s+ else s)+ (concatMap (attribute_descendant_step m) cs) al+attribute_descendant_step m _ = [] {------------ Functions --------------------------------------------------------------} +-- find the value of a variable in an association list+findV var env+ = case filter (\(n,_) -> n==var) env of+ (_,b):_ -> b+ _ -> error ("Undefined variable: "++var)++-- is the variable defined in the association list?+memV var env+ = case filter (\(n,_) -> n==var) env of+ (_,b):_ -> True+ _ -> False++ -- 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"+trueXT = XBool True toString :: XSeq -> [String] toString xs = foldr (\x r -> case x of- XElem _ _ [XText t] -> t:r+ XElem _ _ _ [XText t] -> t:r+ XElem _ _ _ [XInt n] -> (show n):r+ XElem _ _ _ [XFloat n] -> (show n):r+ XElem _ _ _ [XBool n] -> (show n):r XText t -> t:r XInt n -> (show n):r XFloat n -> (show n):r+ XBool n -> (show n):r _ -> r) [] xs readNum :: String -> Maybe XTree@@ -139,10 +166,13 @@ toNum :: XSeq -> XSeq toNum xs = foldr (\x r -> case x of- XElem _ _ [XText s]+ XElem _ _ _ [XText s] -> case readNum s of Just t -> t:r _ -> r+ XElem _ _ _ [z@(XInt n)] -> z:r+ XElem _ _ _ [z@(XFloat n)] -> z:r+ XElem _ _ _ [z@(XBool n)] -> z:r XInt n -> x:r XFloat n -> x:r XText s -> case readNum s of@@ -152,15 +182,20 @@ 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+ XElem _ _ _ [z@(XText _)] -> z:r+ XElem _ _ _ [z@(XInt _)] -> z:r+ XElem _ _ _ [z@(XFloat _)] -> z:r+ XElem _ _ _ [z@(XBool _)] -> z:r XText _ -> x:r XInt _ -> x:r XFloat _ -> x:r+ XBool _ -> x:r _ -> r) [] xs toFloat :: XTree -> Float+toFloat (XText s) = case readNum s of+ Just (XInt n) -> fromIntegral n+ Just (XFloat n) -> n toFloat (XInt n) = fromIntegral n toFloat (XFloat n) = n @@ -179,16 +214,28 @@ arithmetic op (XInt n) (XFloat m) = XFloat (op (fromIntegral n) m) compareXTrees :: XTree -> XTree -> Ordering-compareXTrees (XElem _ _ _) _ = EQ-compareXTrees _ (XElem _ _ _) = EQ+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+compareXTrees (XText n) (XText m) = compare n m+compareXTrees x y = compare (toFloat x) (toFloat y) +strictCompareOne [XInt n] [XInt m] = compare n m+strictCompareOne [XFloat n] [XFloat m] = compare n m+strictCompareOne [XFloat n] [XInt m] = compare n (fromIntegral m)+strictCompareOne [XInt n] [XFloat m] = compare (fromIntegral n) m+strictCompareOne [XText n] [XText m] = compare n m+strictCompareOne x y = error ("Illegal operands in strict comparison: "++(show x)++" "++(show y))++strictCompare :: XSeq -> XSeq -> Ordering+strictCompare [XElem _ _ _ x] [XElem _ _ _ y] = strictCompareOne x y+strictCompare x [XElem _ _ _ y] = strictCompareOne x y+strictCompare [XElem _ _ _ x] y = strictCompareOne x y+strictCompare x y = strictCompareOne x y+ compareXSeqs :: Bool -> XSeq -> XSeq -> Ordering compareXSeqs ord xs ys = let comps = [ compareXTrees x y | x <- xs, y <- ys ]@@ -204,30 +251,55 @@ then LT else EQ +conditionTest :: XSeq -> Bool+conditionTest [] = False+conditionTest [XText ""] = False+conditionTest [XInt 0] = False+conditionTest [XBool False] = False+conditionTest _ = True ++-- XPath steps+paths :: [(Tag,Q Exp)]+paths = [ ( "child_step", [| child_step |] ),+ ( "descendant_step", [| descendant_step |] ),+ ( "attribute_step", [| attribute_step |] ),+ ( "attribute_descendant_step", [| attribute_descendant_step |] )+ ]++ 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] ] |] ),+functions = [ ( "=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] |] ),+ ( "!=", 2, \[xs,ys] -> [| if null [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] then [trueXT] else [] |] ),+ ( ">", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == GT ] |] ),+ ( "<", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == LT ] |] ),+ ( ">=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [GT,EQ] ] |] ),+ ( "<=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [LT,EQ] ] |] ),+ ( "eq", 2, \[xs,ys] -> [| if strictCompare $xs $ys == EQ then [trueXT] else [] |] ),+ ( "neq", 2, \[xs,ys] -> [| if strictCompare $xs $ys /= EQ then [trueXT] else [] |] ),+ ( "lt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == LT then [trueXT] else [] |] ),+ ( "gt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == GT then [trueXT] else [] |] ),+ ( "le", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [LT,EQ] then [trueXT] else [] |] ),+ ( "ge", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [GT,EQ] then [trueXT] else [] |] ),+ ( "<<", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _ <- $ys, ox < oy ] |] ),+ ( ">>", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _ <- $ys, ox > oy ] |] ),+ ( "is", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _ <- $ys, ox == oy ] |] ), ( "+", 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] -> [| [ XInt (div x y) | (XInt x) <- toNum $xs, (XInt y) <- toNum $ys ] |] ),+ ( "mod", 2, \[xs,ys] -> [| [ XInt (mod x y) | (XInt x) <- toNum $xs, (XInt 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] |] ),+ ( "and", 2, \[xs,ys] -> [| if (conditionTest $xs) && (conditionTest $ys) then [trueXT] else [] |] ),+ ( "or", 2, \[xs,ys] -> [| if (conditionTest $xs) || (conditionTest $ys) then [trueXT] else [] |] ),+ ( "not", 1, \[xs] -> [| if (conditionTest $xs) then [] else [trueXT] |] ),+ ( "some", 1, \[xs] -> [| if (conditionTest $xs) then [trueXT] else [] |] ), ( "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 ])@@ -236,24 +308,20 @@ ( "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 |] ),+ ( "string", 1, \[xs] -> [| text $xs |] ), ( "data", 1, \[xs] -> [| text $xs |] ), ( "node", 1, \[xs] -> [| $xs |] ), ( "empty", 0, \[] -> [| [] |] ), ( "true", 0, \[] -> [| [trueXT] |] ), ( "false", 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 ] |] ),- ( "child_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 |] ),+ ( "if", 3, \[cs,ts,es] -> [| if conditionTest $cs then $ts else $es |] ), ( "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 ] |] ),+ case x of XElem t _ _ _ -> t==tag || tag=="*"; _ -> False ] |] ),+ ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute_step tag x ] |] ),+ ( "name", 1, \[xs] -> [| [ XText tag | XElem tag _ _ _ <- $xs ] |] ), ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ), ( "concatenate", 2, \[xs,ys] -> [| $xs ++ $ys |] ),- ( "concat", 2, \[xs,ys] -> [| [ XText (x++y) | x <- toString $xs, y <- toString $ys ] |] ),- ( "distinct-nodes", 1, \[xs] -> [| distinct $xs |] ),+ ( "concat", 2, \[xs,ys] -> [| [ XText ((showXS $xs)++(showXS $ys)) ] |] ), ( "distinct-values", 1, \[xs] -> [| distinct $xs |] ), ( "union", 2, \[xs,ys] -> [| distinct ($xs ++ $ys) |] ), ( "intersect", 2, \[xs,ys] -> [| filter (\x -> elem x $ys) $xs |] ),@@ -262,7 +330,7 @@ ] --- functions to be used in the interpreter+-- functions to be used by 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]@@ -271,14 +339,23 @@ in [| $entry : $r |]) [| [] |] functions +-- XPath steps to be used by the interpreter+-- when evaluated, it gives [(String,Tag->XTree->XSeq)]+pFunctions = foldr (\(pname,p) r -> let pn = litE (StringL pname) in [| ($pn,$p) : $r |]) [| [] |] paths++ -- make a function call callF :: Tag -> Function-callF fname args = case filter (\(n,_,_) -> n==fname) functions of+callF fname args = case filter (\(n,_,_) -> n == fname || ("fn:"++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)+ let itp = case args of+ [] -> [t| () |]+ [_] -> [t| XSeq |]+ _ -> 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)@@ -287,9 +364,23 @@ {------------ Remove Backward Steps and Optimize ------------------------------------} +-- collect attribute constructions inside element constructions+collect_attributes :: Ast -> (Ast,[Ast])+collect_attributes (Ast "attribute_construction" [attr,value])+ = (Ast "call" [Avar "empty"],[Ast "pair" [attr,value]])+collect_attributes (Ast "call" [Avar "concatenate",x,y])+ = let (cx,ax) = collect_attributes x+ (cy,ay) = collect_attributes y+ in (Ast "call" [Avar "concatenate",cx,cy],ax++ay)+collect_attributes (Ast "step" (e:es))+ = let (ce,ae) = collect_attributes e+ in (Ast "step" (ce:es),ae)+collect_attributes e = (e,[])++ -- does the expression contain a $var/.. ? parentOfVar :: Ast -> String -> Bool-parentOfVar (Ast "call" [Avar "parent",Avar x]) var = x == var+parentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [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)@@ -298,12 +389,15 @@ -- replace $var/.. with $nvar replaceParentOfVar :: Ast -> String -> String -> Ast-replaceParentOfVar (Ast "call" [Avar "parent",Avar x]) var nvar | x == var = Avar nvar+replaceParentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [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 (Ast f args) var nvar+ = Ast f (map (\x -> replaceParentOfVar x var nvar) args) replaceParentOfVar e _ _ = e @@ -315,46 +409,56 @@ 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 (Ast "step" ((Ast "child_step" [tag,x]):preds))+ = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),x,True,tag)+removeParent (Ast "step" ((Ast "descendant_step" [tag,x]):preds))+ = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),+ Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),True,tag)+removeParent (Ast "step" ((Ast "attribute_step" [tag,x]):preds))+ = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),x,False,tag)+removeParent (Ast "step" ((Ast "descendant_attribute_step" [tag,x]):preds))+ = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),+ Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),False,tag)+removeParent (Ast "step" (x:xs))+ = let (nx,cond,childp,tag) = removeParent x+ in (Ast "step" (nx:xs),cond,childp,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])+optimize (Ast "step" [Ast "parent_step" [Ast "step" [Ast "parent_step" x]]])+ = let nx = optimize (Ast "step" [Ast "parent_step" x])+ in optimize (Ast "step" [Ast "parent_step" [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]+optimize (Ast "step" [Ast "parent_step" [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")]])+ | 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 "step" [ Ast (if childp+ then "child_step"+ else "attribute_step")+ [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")]])+ | 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 "step" [ Ast (if childp+ then "child_step"+ else "attribute_step")+ [tag,Avar (var++"_parent")] ],+ replaceParentOfVar body var (var++"_parent")]])+optimize (Ast "element_construction" [tag,content])+ = let (nc,attrs) = collect_attributes content+ in optimize (Ast "construction" [tag,Ast "attributes" attrs,nc]) -- needs more rules optimize (Ast n args) = Ast n (map optimize args) optimize e = e@@ -365,18 +469,46 @@ -- does the expression contain a last()? containsLast :: Ast -> Bool-containsLast (Ast "call" [Avar "last"]) = True+containsLast (Ast "step" [Ast "call" [Avar "last"]]) = True containsLast (Ast f _) | elem f ["let","for","predicate"] = False+containsLast (Ast "step" _) = False containsLast (Ast _ args) = or (map containsLast args) containsLast _ = False +-- Each XPath predicate must calculate position() and last() from its input XSeq+-- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)+compilePredicates :: [Ast] -> Q Exp -> Q Exp+compilePredicates [] xs = xs+compilePredicates (pred:preds) xs+ | containsLast pred -- blocking: use only when last() is used in the predicate+ = compilePredicates preds+ [| let bl = $xs+ len = length bl+ in foldir (\x i r -> if case $(compile pred [| [ x ] |] [| [XInt i] |] [| [XInt len] |]) of+ [XInt k] -> k == i -- indexing+ b -> conditionTest b+ then x:r else r) [] bl 1 |]+compilePredicates (pred:preds) xs+ = compilePredicates preds+ [| foldir (\x i r -> if case $(compile pred [| [ x ] |] [| [XInt i] |] [| [] |]) of+ [XInt k] -> k == i -- indexing+ b -> conditionTest b+ then x:r else r) [] $xs 1 |]+++-- extract the QName+qName :: XSeq -> Tag+qName [XText s] = s+qName e = error ("Invalid QName: "++(show e))++ -- 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())+-- context: context node (XPath .)+-- position: the element position in the parent sequence (XPath position())+-- last: the length of the parent sequence (XPath last()) compile :: Ast -> Q Exp -> Q Exp -> Q Exp -> Q Exp-compile e context index seqSize+compile e context position last = case e of Avar "." -> context Avar v -> let x = varE (mkName v)@@ -387,77 +519,76 @@ 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 "context" [v,body]+ -> compile body (compile v context position last) position last+ Ast "doc" [Aint n] -> let d = varE (mkName ("_doc"++(show n))) in [| [ $d ] |] Ast "call" [Avar "position"]- -> index+ -> position 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 (text $vc)) : $r |])- [| [] |] al- ct = litE (StringL tag)- bc = compile body context index seqSize- in [| [ XElem $ct $alc $bc ] |]+ -> last+ Ast "step" [Ast path_step [Astring tag,body]]+ | memV path_step paths+ -> let bc = compile body context position last+ tc = litE (stringL tag)+ in [| foldr (\a s -> ($(findV path_step paths) $tc a)++s) [] $bc |]+ Ast "step" ((Ast path_step [Astring tag,body]):predicates)+ | memV path_step paths+ -> let bc = compile body context position last+ tc = litE (stringL tag)+ in [| foldr (\x r -> $(compilePredicates predicates [| $(findV path_step paths) $tc x |])++r)+ [] $bc |]+ Ast "step" [exp]+ -> compile exp context position last+ Ast "step" (exp:predicates)+ -> compilePredicates predicates (compile exp context position last) 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 |]+ -> compilePredicates [condition] (compile body context position last)+ Ast "call" ((Avar f):args)+ -> callF f (map (\x -> compile x context position last) args)+ Ast "construction" [Astring tag,Ast "attributes" [],body]+ -> let ct = litE (StringL tag)+ bc = compile body context position last+ in [| [ XElem $ct [] 0 $bc ] |]+ Ast "construction" [tag,Ast "attributes" al,body]+ -> let alc = foldr (\(Ast "pair" [a,v]) r+ -> let ac = compile a context position last+ vc = compile v context position last+ in [| (qName $ac,showXS (text $vc)) : $r |]) [| [] |] al+ ct = compile tag context position last+ bc = compile body context position last+ in [| [ XElem (qName $ct) $alc 0 $bc ] |] 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)+ -> do s <- compile source context position last+ b <- compile body context position last+ 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 |]+ -> let b = compile body [| $(varE (mkName var)) |] [| [] |] [| [] |]+ f = lamE [varP (mkName var)] [| \x -> $b ++ x |]+ s = compile source context position last+ 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 |]+ -> 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 position last+ 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 ] |]+ -> let res = foldl (\r a -> let ac = compile a context position last+ in [| $r++[text $ac] |] )+ [| [ $(compile exp context position last) ] |] 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))+ -> let ce = compile exp context position last+ 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@@ -466,6 +597,8 @@ case query of Ast "call" [Avar "doc",file] -> (Ast "doc" [Aint count], count+1, [(count,file)])+ Ast "call" [Avar "fn: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))@@ -474,20 +607,33 @@ _ -> (query,count,[]) +-- optimize and compile an AST+compileAst :: Ast -> Q Exp+compileAst ast = compile (optimize ast) [| [] |] [| [] |] [| [] |]++ -- 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+compileQuery :: [Ast] -> Q Exp+compileQuery ((Ast "function" ((Avar f):b:args)):xs)+ = let lvars = case args of+ [Astring a] -> [varP (mkName a)]+ _ -> [tupP (map (\(Avar a) -> varP (mkName a)) args)]+ in letE [valD (varP (mkName f)) (normalB (lamE lvars (compileAst b))) []]+ (compileQuery xs)+compileQuery ((Ast "variable" [Avar v,u]):xs)+ = letE [valD (varP (mkName v)) (normalB (compileAst u)) []]+ (compileQuery xs)+compileQuery [query]+ = let (ast,_,ns) = getDocs query 0+ code = compileAst ast+ in foldr (\(n,file) r -> let d = lamE [varP (mkName ("_doc"++(show n)))] r+ in [| do let [XText f] = $(compileAst file)+ doc <- readFile f+ $d (materialize (parseDocument doc)) |])+ [| return $code |] ns --- Display the AST and the Haskell code of an input XQuery+-- Debugging: 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)@@ -496,18 +642,17 @@ putStrLn "Optimized AST:" putStrLn (show opt) putStrLn "Haskell Code:"- let code = compileQuery opt [| [] |]+ let code = compileQuery ast 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)))) [| [] |] [| [] |] [| [] |]+xe query = compileAst (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))) [| [] |]-+xq query = compileQuery (parse (scan query))
XQueryInterpreter.hs view
@@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/-- Creation: 03/22/08, last update: 03/25/08+- Creation: 03/22/08, last update: 03/30/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.@@ -24,96 +24,134 @@ import XQueryCompiler +-- system functions (=, concat, etc) systemFunctions :: [(String,Int,[XSeq]->XSeq)] systemFunctions = $(iFunctions) +-- XPath step functions (child, descendant, etc)+pathFunctions :: [(String,Tag->XTree->XSeq)]+pathFunctions = $(pFunctions)++-- run-time bindings of FLOWR variables type Environment = [(String,XSeq)] --- user-defined function: (fname,parameters,body)+-- a user-defined function is (fname,parameters,body) type Functions = [(String,[String],Ast)] -findV var env- = case filter (\(n,_) -> n==var) env of- (_,b):_ -> b- _ -> error ("Undefined variable: "++var)+-- Each XPath predicate must calculate position() and last() from its input XSeq+-- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)+applyPredicates :: [Ast] -> XSeq -> Environment -> Functions -> XSeq+applyPredicates [] xs _ _ = xs+applyPredicates (pred:preds) xs env fncs+ | containsLast pred -- blocking: use only when last() is used in the predicate+ = let last = length xs+ in applyPredicates preds+ (foldir (\x i r -> if case eval pred [x] i last env fncs of+ [XInt k] -> k == i -- indexing+ b -> conditionTest b+ then x:r else r) [] xs 1) env fncs+applyPredicates (pred:preds) xs env fncs+ = applyPredicates preds+ (foldir (\x i r -> if case eval pred [x] i 0 env fncs of+ [XInt k] -> k == i -- indexing+ b -> conditionTest b+ then x:r else r) [] xs 1) env fncs -eval :: Ast -> Environment -> Functions -> XSeq-eval e env fncs+-- The XQuery interpreter+-- context: context node (XPath .)+-- position: the element position in the parent sequence (XPath position())+-- last: the length of the parent sequence (XPath last())+-- env: contains FLOWR variable bindings+-- fncs: user-defined functions+eval :: Ast -> XSeq -> Int -> Int -> Environment -> Functions -> XSeq+eval e context position last env fncs = case e of+ Avar "." -> context 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 ((zipWith (\p a -> (p,eval a env fncs))- 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,showXS (text (eval v env fncs)))) al- in [ XElem tag alc (eval body env fncs) ]+ Ast "context" [v,body] -> context+ Ast "call" [Avar "position"] -> [XInt position]+ Ast "call" [Avar "last"] -> [XInt last]+ Ast "step" [Ast path_step [Astring tag,body]]+ | memV path_step pathFunctions+ -> foldr (\x r -> ((findV path_step pathFunctions) tag x)++r)+ [] (eval body context position last env fncs)+ Ast "step" ((Ast path_step [Astring tag,body]):predicates)+ | memV path_step pathFunctions+ -> foldr (\x r -> (applyPredicates predicates ((findV path_step pathFunctions) tag x) env fncs)++r)+ [] (eval body context position last env fncs)+ Ast "step" [exp]+ -> eval exp context position last env fncs+ Ast "step" (exp:predicates)+ -> applyPredicates predicates (eval exp context position last env fncs) 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+ -> applyPredicates [condition] (eval body context position last env fncs) env fncs+ Ast "call" ((Avar fname):args)+ -> case filter (\(n,_,_) -> n == fname || ("fn:"++n) == fname) systemFunctions of+ [(_,len,f)] -> if (length args) == len+ then f (map (\x -> eval x context position last 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 context 0 0 + ((zipWith (\p a -> (p,eval a context position last env fncs))+ params args)++env) fncs+ else error ("Wrong number of arguments in function call: "++fname)+ _ -> error ("Undefined function: "++fname)+ Ast "construction" [Astring tag,Ast "attributes" [],body]+ -> [ XElem tag [] 0 (eval body context position last env fncs) ]+ Ast "construction" [tag,Ast "attributes" al,body]+ -> let alc = map (\(Ast "pair" [a,v])+ -> let ac = eval a context position last env fncs+ vc = eval v context position last env fncs+ in (qName ac,showXS (text vc))) al+ ct = eval tag context position last env fncs+ bc = eval body context position last env fncs+ in [ XElem (qName ct) alc 0 bc ] Ast "let" [Avar var,source,body]- -> eval body ((var,eval source env fncs):env) fncs+ -> eval body context position last ((var,eval source context position last 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)+ -> foldr (\a r -> (eval body [a] 0 0 ((var,[a]):env) fncs)++r)+ [] (eval source context position last 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+ -> foldir (\a i r -> (eval body [a] i 0 ((var,[a]):(ivar,[XInt i]):env) fncs)++r)+ [] (eval source context position last 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) ]+ -> [ XElem "" [] 0 (foldl (\r a -> r++[XElem "" [] 0 (text (eval a context position last env fncs))])+ [XElem "" [] 0 (eval exp context position last 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))+ -> let ce = map (\(XElem _ _ _ xs) -> map (\(XElem _ _ _ ys) -> ys) xs)+ (eval exp context position last 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)+ = do let asts = parse (scan query)+ fncs = foldr (\e r -> case e of+ Ast "function" ((Avar f):b:args) -> (f,map (\(Avar v) -> v) args,optimize b):r+ _ -> r) [] asts+ vars = foldl (\r e -> case e of+ Ast "variable" [Avar v,u] -> (v,eval (optimize u) [] 0 0 r fncs):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) [] 0 0 (env++vars) fncs) -- Read an XQuery fom a file and run it
XQueryParser.hs view
@@ -7,4389 +7,5632 @@ import GlaExts #endif --- parser produced by Happy Version 1.16--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 (() -> ())-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 (70#) = happyShift action_23-action_0 (71#) = happyShift action_24-action_0 (75#) = happyShift action_25-action_0 (77#) = happyShift action_26-action_0 (78#) = happyShift action_34-action_0 (82#) = happyShift action_27-action_0 (84#) = happyShift action_28-action_0 (86#) = happyShift action_29-action_0 (87#) = happyShift action_30-action_0 (88#) = 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 (70#) = happyShift action_23-action_1 (71#) = happyShift action_24-action_1 (75#) = happyShift action_25-action_1 (77#) = happyShift action_26-action_1 (82#) = happyShift action_27-action_1 (84#) = happyShift action_28-action_1 (86#) = happyShift action_29-action_1 (87#) = happyShift action_30-action_1 (88#) = 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_98--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_55--action_5 x = happyTcHack x happyReduce_14--action_6 x = happyTcHack x happyReduce_13--action_7 (52#) = happyShift action_78-action_7 (73#) = happyShift action_79-action_7 x = happyTcHack x happyFail--action_8 x = happyTcHack x happyReduce_12--action_9 (33#) = happyShift action_76-action_9 (76#) = happyShift action_77-action_9 (22#) = happyGoto action_74-action_9 (23#) = happyGoto action_75-action_9 x = happyTcHack x happyReduce_82--action_10 x = happyTcHack x happyReduce_93--action_11 x = happyTcHack x happyReduce_95--action_12 (84#) = happyShift action_28-action_12 (6#) = happyGoto action_62-action_12 (10#) = happyGoto action_73-action_12 x = happyTcHack x happyFail--action_13 (84#) = 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 (70#) = happyShift action_23-action_14 (71#) = happyShift action_24-action_14 (75#) = happyShift action_25-action_14 (77#) = happyShift action_26-action_14 (82#) = happyShift action_27-action_14 (84#) = happyShift action_28-action_14 (86#) = happyShift action_29-action_14 (87#) = happyShift action_30-action_14 (88#) = 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 (70#) = happyShift action_23-action_15 (71#) = happyShift action_24-action_15 (75#) = happyShift action_25-action_15 (77#) = happyShift action_26-action_15 (82#) = happyShift action_27-action_15 (84#) = happyShift action_28-action_15 (86#) = happyShift action_29-action_15 (87#) = happyShift action_30-action_15 (88#) = 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 (70#) = happyShift action_23-action_16 (71#) = happyShift action_24-action_16 (75#) = happyShift action_25-action_16 (77#) = happyShift action_26-action_16 (82#) = happyShift action_27-action_16 (84#) = happyShift action_28-action_16 (86#) = happyShift action_29-action_16 (87#) = happyShift action_30-action_16 (88#) = 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 (70#) = happyShift action_23-action_17 (71#) = happyShift action_24-action_17 (75#) = happyShift action_25-action_17 (77#) = happyShift action_26-action_17 (82#) = happyShift action_27-action_17 (84#) = happyShift action_28-action_17 (86#) = happyShift action_29-action_17 (87#) = happyShift action_30-action_17 (88#) = 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_96--action_19 (77#) = 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 (70#) = happyShift action_23-action_20 (71#) = happyShift action_24-action_20 (75#) = happyShift action_25-action_20 (77#) = happyShift action_26-action_20 (82#) = happyShift action_27-action_20 (84#) = happyShift action_28-action_20 (86#) = happyShift action_29-action_20 (87#) = happyShift action_30-action_20 (88#) = 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 (84#) = happyShift action_28-action_21 (6#) = happyGoto action_62-action_21 (10#) = happyGoto action_63-action_21 x = happyTcHack x happyFail--action_22 (84#) = 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 (77#) = happyShift action_26-action_25 (82#) = happyShift action_27-action_25 (84#) = 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_97--action_27 x = happyTcHack x happyReduce_99--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 (89#) = 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 (85#) = happyShift action_55-action_33 x = happyTcHack x happyReduce_1--action_34 (79#) = happyShift action_35-action_34 x = happyTcHack x happyFail--action_35 (77#) = happyShift action_137-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 (70#) = happyShift action_23-action_36 (71#) = happyShift action_24-action_36 (75#) = happyShift action_25-action_36 (77#) = happyShift action_26-action_36 (82#) = happyShift action_27-action_36 (84#) = happyShift action_28-action_36 (86#) = happyShift action_29-action_36 (87#) = happyShift action_30-action_36 (88#) = happyShift action_31-action_36 (6#) = happyGoto action_2-action_36 (7#) = happyGoto action_136-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 (70#) = happyShift action_23-action_37 (71#) = happyShift action_24-action_37 (75#) = happyShift action_25-action_37 (77#) = happyShift action_26-action_37 (82#) = happyShift action_27-action_37 (84#) = happyShift action_28-action_37 (86#) = happyShift action_29-action_37 (87#) = happyShift action_30-action_37 (88#) = happyShift action_31-action_37 (6#) = happyGoto action_2-action_37 (7#) = happyGoto action_135-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 (70#) = happyShift action_23-action_38 (71#) = happyShift action_24-action_38 (75#) = happyShift action_25-action_38 (77#) = happyShift action_26-action_38 (82#) = happyShift action_27-action_38 (84#) = happyShift action_28-action_38 (86#) = happyShift action_29-action_38 (87#) = happyShift action_30-action_38 (88#) = happyShift action_31-action_38 (6#) = happyGoto action_2-action_38 (7#) = happyGoto action_134-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 (70#) = happyShift action_23-action_39 (71#) = happyShift action_24-action_39 (75#) = happyShift action_25-action_39 (77#) = happyShift action_26-action_39 (82#) = happyShift action_27-action_39 (84#) = happyShift action_28-action_39 (86#) = happyShift action_29-action_39 (87#) = happyShift action_30-action_39 (88#) = happyShift action_31-action_39 (6#) = happyGoto action_2-action_39 (7#) = happyGoto action_133-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 (70#) = happyShift action_23-action_40 (71#) = happyShift action_24-action_40 (75#) = happyShift action_25-action_40 (77#) = happyShift action_26-action_40 (82#) = happyShift action_27-action_40 (84#) = happyShift action_28-action_40 (86#) = happyShift action_29-action_40 (87#) = happyShift action_30-action_40 (88#) = happyShift action_31-action_40 (6#) = happyGoto action_2-action_40 (7#) = happyGoto action_132-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 (70#) = happyShift action_23-action_41 (71#) = happyShift action_24-action_41 (75#) = happyShift action_25-action_41 (77#) = happyShift action_26-action_41 (82#) = happyShift action_27-action_41 (84#) = happyShift action_28-action_41 (86#) = happyShift action_29-action_41 (87#) = happyShift action_30-action_41 (88#) = happyShift action_31-action_41 (6#) = happyGoto action_2-action_41 (7#) = happyGoto action_131-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 (70#) = happyShift action_23-action_42 (71#) = happyShift action_24-action_42 (75#) = happyShift action_25-action_42 (77#) = happyShift action_26-action_42 (82#) = happyShift action_27-action_42 (84#) = happyShift action_28-action_42 (86#) = happyShift action_29-action_42 (87#) = happyShift action_30-action_42 (88#) = happyShift action_31-action_42 (6#) = happyGoto action_2-action_42 (7#) = happyGoto action_130-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 (70#) = happyShift action_23-action_43 (71#) = happyShift action_24-action_43 (75#) = happyShift action_25-action_43 (77#) = happyShift action_26-action_43 (82#) = happyShift action_27-action_43 (84#) = happyShift action_28-action_43 (86#) = happyShift action_29-action_43 (87#) = happyShift action_30-action_43 (88#) = happyShift action_31-action_43 (6#) = happyGoto action_2-action_43 (7#) = happyGoto action_129-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 (70#) = happyShift action_23-action_44 (71#) = happyShift action_24-action_44 (75#) = happyShift action_25-action_44 (77#) = happyShift action_26-action_44 (82#) = happyShift action_27-action_44 (84#) = happyShift action_28-action_44 (86#) = happyShift action_29-action_44 (87#) = happyShift action_30-action_44 (88#) = happyShift action_31-action_44 (6#) = happyGoto action_2-action_44 (7#) = happyGoto action_128-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 (70#) = happyShift action_23-action_45 (71#) = happyShift action_24-action_45 (75#) = happyShift action_25-action_45 (77#) = happyShift action_26-action_45 (82#) = happyShift action_27-action_45 (84#) = happyShift action_28-action_45 (86#) = happyShift action_29-action_45 (87#) = happyShift action_30-action_45 (88#) = happyShift action_31-action_45 (6#) = happyGoto action_2-action_45 (7#) = happyGoto action_127-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 (70#) = happyShift action_23-action_46 (71#) = happyShift action_24-action_46 (75#) = happyShift action_25-action_46 (77#) = happyShift action_26-action_46 (82#) = happyShift action_27-action_46 (84#) = happyShift action_28-action_46 (86#) = happyShift action_29-action_46 (87#) = happyShift action_30-action_46 (88#) = happyShift action_31-action_46 (6#) = happyGoto action_2-action_46 (7#) = happyGoto action_126-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 (70#) = happyShift action_23-action_47 (71#) = happyShift action_24-action_47 (75#) = happyShift action_25-action_47 (77#) = happyShift action_26-action_47 (82#) = happyShift action_27-action_47 (84#) = happyShift action_28-action_47 (86#) = happyShift action_29-action_47 (87#) = happyShift action_30-action_47 (88#) = happyShift action_31-action_47 (6#) = happyGoto action_2-action_47 (7#) = happyGoto action_125-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 (70#) = happyShift action_23-action_48 (71#) = happyShift action_24-action_48 (75#) = happyShift action_25-action_48 (77#) = happyShift action_26-action_48 (82#) = happyShift action_27-action_48 (84#) = happyShift action_28-action_48 (86#) = happyShift action_29-action_48 (87#) = happyShift action_30-action_48 (88#) = happyShift action_31-action_48 (6#) = happyGoto action_2-action_48 (7#) = happyGoto action_124-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 (70#) = happyShift action_23-action_49 (71#) = happyShift action_24-action_49 (75#) = happyShift action_25-action_49 (77#) = happyShift action_26-action_49 (82#) = happyShift action_27-action_49 (84#) = happyShift action_28-action_49 (86#) = happyShift action_29-action_49 (87#) = happyShift action_30-action_49 (88#) = happyShift action_31-action_49 (6#) = happyGoto action_2-action_49 (7#) = happyGoto action_123-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 (70#) = happyShift action_23-action_50 (71#) = happyShift action_24-action_50 (75#) = happyShift action_25-action_50 (77#) = happyShift action_26-action_50 (82#) = happyShift action_27-action_50 (84#) = happyShift action_28-action_50 (86#) = happyShift action_29-action_50 (87#) = happyShift action_30-action_50 (88#) = happyShift action_31-action_50 (6#) = happyGoto action_2-action_50 (7#) = happyGoto action_122-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 (70#) = happyShift action_23-action_51 (71#) = happyShift action_24-action_51 (75#) = happyShift action_25-action_51 (77#) = happyShift action_26-action_51 (82#) = happyShift action_27-action_51 (84#) = happyShift action_28-action_51 (86#) = happyShift action_29-action_51 (87#) = happyShift action_30-action_51 (88#) = happyShift action_31-action_51 (6#) = happyGoto action_2-action_51 (7#) = happyGoto action_121-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 (70#) = happyShift action_23-action_52 (71#) = happyShift action_24-action_52 (75#) = happyShift action_25-action_52 (77#) = happyShift action_26-action_52 (82#) = happyShift action_27-action_52 (84#) = happyShift action_28-action_52 (86#) = happyShift action_29-action_52 (87#) = happyShift action_30-action_52 (88#) = happyShift action_31-action_52 (6#) = happyGoto action_2-action_52 (7#) = happyGoto action_120-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 (70#) = happyShift action_23-action_53 (71#) = happyShift action_24-action_53 (75#) = happyShift action_25-action_53 (77#) = happyShift action_26-action_53 (82#) = happyShift action_27-action_53 (84#) = happyShift action_28-action_53 (86#) = happyShift action_29-action_53 (87#) = happyShift action_30-action_53 (88#) = happyShift action_31-action_53 (6#) = happyGoto action_2-action_53 (7#) = happyGoto action_119-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 (70#) = happyShift action_23-action_54 (71#) = happyShift action_24-action_54 (75#) = happyShift action_25-action_54 (77#) = happyShift action_26-action_54 (82#) = happyShift action_27-action_54 (84#) = happyShift action_28-action_54 (86#) = happyShift action_29-action_54 (87#) = happyShift action_30-action_54 (88#) = happyShift action_31-action_54 (6#) = happyGoto action_2-action_54 (7#) = happyGoto action_118-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_117-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 (70#) = happyShift action_23-action_56 (71#) = happyShift action_24-action_56 (75#) = happyShift action_25-action_56 (77#) = happyShift action_26-action_56 (82#) = happyShift action_27-action_56 (84#) = happyShift action_28-action_56 (86#) = happyShift action_29-action_56 (87#) = happyShift action_30-action_56 (88#) = happyShift action_31-action_56 (6#) = happyGoto action_2-action_56 (7#) = happyGoto action_68-action_56 (8#) = happyGoto action_116-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 (76#) = happyShift action_77-action_57 (22#) = happyGoto action_115-action_57 (23#) = happyGoto action_75-action_57 x = happyTcHack x happyReduce_83--action_58 (77#) = happyShift action_114-action_58 x = happyTcHack x happyFail--action_59 (77#) = happyShift action_113-action_59 x = happyTcHack x happyFail--action_60 (64#) = happyShift action_112-action_60 x = happyTcHack x happyFail--action_61 (63#) = happyShift action_111-action_61 x = happyTcHack x happyReduce_43--action_62 (62#) = happyShift action_109-action_62 (80#) = happyShift action_110-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 (77#) = happyShift action_108-action_65 (20#) = happyGoto action_107-action_65 x = happyTcHack x happyReduce_68--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_101--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 (74#) = happyShift action_103-action_72 x = happyTcHack x happyFail--action_73 (63#) = happyShift action_101-action_73 (74#) = happyShift action_102-action_73 x = happyTcHack x happyFail--action_74 (76#) = happyShift action_77-action_74 (23#) = happyGoto action_100-action_74 x = happyTcHack x happyReduce_84--action_75 x = happyTcHack x happyReduce_86--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 (70#) = happyShift action_23-action_76 (71#) = happyShift action_24-action_76 (75#) = happyShift action_25-action_76 (77#) = happyShift action_26-action_76 (82#) = happyShift action_27-action_76 (84#) = happyShift action_28-action_76 (86#) = happyShift action_29-action_76 (87#) = happyShift action_30-action_76 (88#) = 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 (75#) = happyShift action_96-action_77 (76#) = happyShift action_97-action_77 (77#) = happyShift action_26-action_77 (81#) = happyShift action_98-action_77 (82#) = happyShift action_27-action_77 (84#) = 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 (72#) = happyShift action_92-action_78 (85#) = happyShift action_93-action_78 (88#) = 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_67--action_80 (66#) = happyShift action_88-action_80 (13#) = happyGoto action_87-action_80 x = happyTcHack x happyReduce_57--action_81 (84#) = happyShift action_28-action_81 (6#) = happyGoto action_62-action_81 (10#) = happyGoto action_86-action_81 x = happyTcHack x happyFail--action_82 (84#) = 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 (70#) = happyShift action_23-action_83 (71#) = happyShift action_24-action_83 (75#) = happyShift action_25-action_83 (77#) = happyShift action_26-action_83 (82#) = happyShift action_27-action_83 (84#) = happyShift action_28-action_83 (86#) = happyShift action_29-action_83 (87#) = happyShift action_30-action_83 (88#) = 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_54--action_85 (63#) = happyShift action_111-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_165-action_87 x = happyTcHack x happyFail--action_88 (67#) = happyShift action_164-action_88 x = happyTcHack x happyFail--action_89 x = happyTcHack x happyReduce_73--action_90 (37#) = happyShift action_160-action_90 (50#) = happyShift action_19-action_90 (72#) = happyShift action_161-action_90 (85#) = happyShift action_162-action_90 (88#) = happyShift action_163-action_90 (17#) = happyGoto action_159-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 (70#) = happyShift action_23-action_91 (71#) = happyShift action_24-action_91 (75#) = happyShift action_25-action_91 (77#) = happyShift action_26-action_91 (82#) = happyShift action_27-action_91 (84#) = happyShift action_28-action_91 (86#) = happyShift action_29-action_91 (87#) = happyShift action_30-action_91 (88#) = happyShift action_31-action_91 (6#) = happyGoto action_2-action_91 (7#) = happyGoto action_68-action_91 (8#) = happyGoto action_158-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 (77#) = happyShift action_157-action_92 x = happyTcHack x happyFail--action_93 x = happyTcHack x happyReduce_72--action_94 x = happyTcHack x happyReduce_71--action_95 (33#) = happyShift action_76-action_95 x = happyTcHack x happyReduce_88--action_96 (35#) = happyShift action_15-action_96 (44#) = happyShift action_18-action_96 (77#) = happyShift action_26-action_96 (82#) = happyShift action_27-action_96 (84#) = happyShift action_28-action_96 (6#) = happyGoto action_2-action_96 (24#) = happyGoto action_156-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 (75#) = happyShift action_155-action_97 (77#) = happyShift action_26-action_97 (82#) = happyShift action_27-action_97 (84#) = happyShift action_28-action_97 (6#) = happyGoto action_2-action_97 (24#) = happyGoto action_154-action_97 (25#) = happyGoto action_10-action_97 (26#) = happyGoto action_11-action_97 x = happyTcHack x happyFail--action_98 x = happyTcHack x happyReduce_92--action_99 (34#) = happyShift action_153-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_87--action_101 (84#) = happyShift action_28-action_101 (6#) = happyGoto action_152-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 (70#) = happyShift action_23-action_102 (71#) = happyShift action_24-action_102 (75#) = happyShift action_25-action_102 (77#) = happyShift action_26-action_102 (82#) = happyShift action_27-action_102 (84#) = happyShift action_28-action_102 (86#) = happyShift action_29-action_102 (87#) = happyShift action_30-action_102 (88#) = happyShift action_31-action_102 (6#) = happyGoto action_2-action_102 (7#) = happyGoto action_151-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 (70#) = happyShift action_23-action_103 (71#) = happyShift action_24-action_103 (75#) = happyShift action_25-action_103 (77#) = happyShift action_26-action_103 (82#) = happyShift action_27-action_103 (84#) = happyShift action_28-action_103 (86#) = happyShift action_29-action_103 (87#) = happyShift action_30-action_103 (88#) = happyShift action_31-action_103 (6#) = happyGoto action_2-action_103 (7#) = happyGoto action_150-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 (70#) = happyShift action_23-action_104 (71#) = happyShift action_24-action_104 (75#) = happyShift action_25-action_104 (77#) = happyShift action_26-action_104 (82#) = happyShift action_27-action_104 (84#) = happyShift action_28-action_104 (86#) = happyShift action_29-action_104 (87#) = happyShift action_30-action_104 (88#) = happyShift action_31-action_104 (6#) = happyGoto action_2-action_104 (7#) = happyGoto action_149-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_100--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 (70#) = happyShift action_23-action_106 (71#) = happyShift action_24-action_106 (75#) = happyShift action_25-action_106 (77#) = happyShift action_26-action_106 (82#) = happyShift action_27-action_106 (84#) = happyShift action_28-action_106 (86#) = happyShift action_29-action_106 (87#) = happyShift action_30-action_106 (88#) = happyShift action_31-action_106 (6#) = happyGoto action_2-action_106 (7#) = happyGoto action_148-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 (77#) = happyShift action_147-action_107 x = happyTcHack x happyReduce_69--action_108 (48#) = happyShift action_146-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 (70#) = happyShift action_23-action_109 (71#) = happyShift action_24-action_109 (75#) = happyShift action_25-action_109 (77#) = happyShift action_26-action_109 (82#) = happyShift action_27-action_109 (84#) = happyShift action_28-action_109 (86#) = happyShift action_29-action_109 (87#) = happyShift action_30-action_109 (88#) = happyShift action_31-action_109 (6#) = happyGoto action_2-action_109 (7#) = happyGoto action_145-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 (84#) = happyShift action_28-action_110 (6#) = happyGoto action_144-action_110 x = happyTcHack x happyFail--action_111 (84#) = happyShift action_28-action_111 (6#) = happyGoto action_143-action_111 x = happyTcHack x happyFail--action_112 (28#) = happyShift action_12-action_112 (29#) = happyShift action_13-action_112 (30#) = happyShift action_14-action_112 (35#) = happyShift action_15-action_112 (42#) = happyShift action_16-action_112 (43#) = happyShift action_17-action_112 (44#) = happyShift action_18-action_112 (50#) = happyShift action_19-action_112 (56#) = happyShift action_20-action_112 (60#) = happyShift action_21-action_112 (61#) = happyShift action_22-action_112 (70#) = happyShift action_23-action_112 (71#) = happyShift action_24-action_112 (75#) = happyShift action_25-action_112 (77#) = happyShift action_26-action_112 (82#) = happyShift action_27-action_112 (84#) = happyShift action_28-action_112 (86#) = happyShift action_29-action_112 (87#) = happyShift action_30-action_112 (88#) = happyShift action_31-action_112 (6#) = happyGoto action_2-action_112 (7#) = happyGoto action_142-action_112 (9#) = happyGoto action_4-action_112 (16#) = happyGoto action_5-action_112 (17#) = happyGoto action_6-action_112 (18#) = happyGoto action_7-action_112 (21#) = happyGoto action_8-action_112 (24#) = happyGoto action_9-action_112 (25#) = happyGoto action_10-action_112 (26#) = happyGoto action_11-action_112 x = happyTcHack x happyFail--action_113 (36#) = happyShift action_141-action_113 x = happyTcHack x happyFail--action_114 (36#) = happyShift action_140-action_114 x = happyTcHack x happyFail--action_115 (76#) = happyShift action_77-action_115 (23#) = happyGoto action_100-action_115 x = happyTcHack x happyReduce_85--action_116 (36#) = happyShift action_139-action_116 (63#) = happyShift action_106-action_116 x = happyTcHack x happyFail--action_117 x = happyTcHack x happyReduce_103--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_33--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_32--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 (54#) = happyShift action_49-action_120 (55#) = happyShift action_50-action_120 (56#) = happyShift action_51-action_120 x = happyTcHack x happyReduce_31--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 (56#) = happyFail-action_121 x = happyTcHack x happyReduce_30--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 (55#) = happyShift action_50-action_122 (56#) = happyShift action_51-action_122 x = happyTcHack x happyReduce_29--action_123 (41#) = happyShift action_36-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 (48#) = happyShift action_43-action_123 (49#) = happyShift action_44-action_123 (50#) = happyShift action_45-action_123 (51#) = happyShift action_46-action_123 (52#) = happyShift action_47-action_123 (53#) = happyShift action_48-action_123 (54#) = happyShift action_49-action_123 (56#) = happyShift action_51-action_123 x = happyTcHack x happyReduce_28--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_27--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_26--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_25--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_24--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_23--action_129 (42#) = happyShift action_37-action_129 (43#) = happyShift action_38-action_129 (44#) = happyShift action_39-action_129 (45#) = happyShift action_40-action_129 (46#) = happyShift action_41-action_129 (47#) = happyShift action_42-action_129 x = happyTcHack x happyReduce_22--action_130 x = happyTcHack x happyReduce_21--action_131 x = happyTcHack x happyReduce_20--action_132 x = happyTcHack x happyReduce_19--action_133 x = happyTcHack x happyReduce_18--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_17--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 x = happyTcHack x happyReduce_16--action_136 (42#) = happyShift action_37-action_136 (43#) = happyShift action_38-action_136 (44#) = happyShift action_39-action_136 (45#) = happyShift action_40-action_136 (46#) = happyShift action_41-action_136 (47#) = happyShift action_42-action_136 (48#) = happyShift action_43-action_136 (49#) = happyShift action_44-action_136 (50#) = happyShift action_45-action_136 (51#) = happyShift action_46-action_136 (52#) = happyShift action_47-action_136 (53#) = happyShift action_48-action_136 x = happyTcHack x happyReduce_15--action_137 (35#) = happyShift action_138-action_137 x = happyTcHack x happyFail--action_138 (36#) = happyShift action_185-action_138 (84#) = happyShift action_28-action_138 (5#) = happyGoto action_183-action_138 (6#) = happyGoto action_184-action_138 x = happyTcHack x happyFail--action_139 x = happyTcHack x happyReduce_102--action_140 x = happyTcHack x happyReduce_64--action_141 x = happyTcHack x happyReduce_63--action_142 (41#) = happyShift action_36-action_142 (42#) = happyShift action_37-action_142 (43#) = happyShift action_38-action_142 (44#) = happyShift action_39-action_142 (45#) = happyShift action_40-action_142 (46#) = happyShift action_41-action_142 (47#) = happyShift action_42-action_142 (48#) = happyShift action_43-action_142 (49#) = happyShift action_44-action_142 (50#) = happyShift action_45-action_142 (51#) = happyShift action_46-action_142 (52#) = happyShift action_47-action_142 (53#) = happyShift action_48-action_142 (54#) = happyShift action_49-action_142 (55#) = happyShift action_50-action_142 (56#) = happyShift action_51-action_142 (57#) = happyShift action_52-action_142 (58#) = happyShift action_53-action_142 (59#) = happyShift action_54-action_142 x = happyTcHack x happyReduce_52--action_143 (64#) = happyShift action_182-action_143 x = happyTcHack x happyFail--action_144 (62#) = happyShift action_181-action_144 x = happyTcHack x happyFail--action_145 (41#) = happyShift action_36-action_145 (42#) = happyShift action_37-action_145 (43#) = happyShift action_38-action_145 (44#) = happyShift action_39-action_145 (45#) = happyShift action_40-action_145 (46#) = happyShift action_41-action_145 (47#) = happyShift action_42-action_145 (48#) = happyShift action_43-action_145 (49#) = happyShift action_44-action_145 (50#) = happyShift action_45-action_145 (51#) = happyShift action_46-action_145 (52#) = happyShift action_47-action_145 (53#) = happyShift action_48-action_145 (54#) = happyShift action_49-action_145 (55#) = happyShift action_50-action_145 (56#) = happyShift action_51-action_145 (57#) = happyShift action_52-action_145 (58#) = happyShift action_53-action_145 (59#) = happyShift action_54-action_145 (80#) = happyShift action_180-action_145 x = happyTcHack x happyReduce_46--action_146 (39#) = happyShift action_178-action_146 (88#) = happyShift action_179-action_146 x = happyTcHack x happyFail--action_147 (48#) = happyShift action_177-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_41--action_149 (32#) = happyShift action_176-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 happyFail--action_150 (41#) = happyShift action_36-action_150 (42#) = happyShift action_37-action_150 (43#) = happyShift action_38-action_150 (44#) = happyShift action_39-action_150 (45#) = happyShift action_40-action_150 (46#) = happyShift action_41-action_150 (47#) = happyShift action_42-action_150 (48#) = happyShift action_43-action_150 (49#) = happyShift action_44-action_150 (50#) = happyShift action_45-action_150 (51#) = happyShift action_46-action_150 (52#) = happyShift action_47-action_150 (53#) = happyShift action_48-action_150 (54#) = happyShift action_49-action_150 (55#) = happyShift action_50-action_150 (56#) = happyShift action_51-action_150 (57#) = happyShift action_52-action_150 (58#) = happyShift action_53-action_150 (59#) = happyShift action_54-action_150 x = happyTcHack x happyReduce_10--action_151 (41#) = happyShift action_36-action_151 (42#) = happyShift action_37-action_151 (43#) = happyShift action_38-action_151 (44#) = happyShift action_39-action_151 (45#) = happyShift action_40-action_151 (46#) = happyShift action_41-action_151 (47#) = happyShift action_42-action_151 (48#) = happyShift action_43-action_151 (49#) = happyShift action_44-action_151 (50#) = happyShift action_45-action_151 (51#) = happyShift action_46-action_151 (52#) = happyShift action_47-action_151 (53#) = happyShift action_48-action_151 (54#) = happyShift action_49-action_151 (55#) = happyShift action_50-action_151 (56#) = happyShift action_51-action_151 (57#) = happyShift action_52-action_151 (58#) = happyShift action_53-action_151 (59#) = happyShift action_54-action_151 x = happyTcHack x happyReduce_9--action_152 (62#) = happyShift action_174-action_152 (80#) = happyShift action_175-action_152 x = happyTcHack x happyFail--action_153 x = happyTcHack x happyReduce_94--action_154 (33#) = happyShift action_76-action_154 x = happyTcHack x happyReduce_90--action_155 (35#) = happyShift action_15-action_155 (44#) = happyShift action_18-action_155 (77#) = happyShift action_26-action_155 (82#) = happyShift action_27-action_155 (84#) = happyShift action_28-action_155 (6#) = happyGoto action_2-action_155 (24#) = happyGoto action_173-action_155 (25#) = happyGoto action_10-action_155 (26#) = happyGoto action_11-action_155 x = happyTcHack x happyFail--action_156 (33#) = happyShift action_76-action_156 x = happyTcHack x happyReduce_89--action_157 (52#) = happyShift action_172-action_157 x = happyTcHack x happyFail--action_158 (38#) = happyShift action_171-action_158 (63#) = happyShift action_106-action_158 x = happyTcHack x happyFail--action_159 x = happyTcHack x happyReduce_77--action_160 (28#) = happyShift action_12-action_160 (29#) = happyShift action_13-action_160 (30#) = happyShift action_14-action_160 (35#) = happyShift action_15-action_160 (42#) = happyShift action_16-action_160 (43#) = happyShift action_17-action_160 (44#) = happyShift action_18-action_160 (50#) = happyShift action_19-action_160 (56#) = happyShift action_20-action_160 (60#) = happyShift action_21-action_160 (61#) = happyShift action_22-action_160 (70#) = happyShift action_23-action_160 (71#) = happyShift action_24-action_160 (75#) = happyShift action_25-action_160 (77#) = happyShift action_26-action_160 (82#) = happyShift action_27-action_160 (84#) = happyShift action_28-action_160 (86#) = happyShift action_29-action_160 (87#) = happyShift action_30-action_160 (88#) = happyShift action_31-action_160 (6#) = happyGoto action_2-action_160 (7#) = happyGoto action_68-action_160 (8#) = happyGoto action_170-action_160 (9#) = happyGoto action_4-action_160 (16#) = happyGoto action_5-action_160 (17#) = happyGoto action_6-action_160 (18#) = happyGoto action_7-action_160 (21#) = happyGoto action_8-action_160 (24#) = happyGoto action_9-action_160 (25#) = happyGoto action_10-action_160 (26#) = happyGoto action_11-action_160 x = happyTcHack x happyFail--action_161 (77#) = happyShift action_169-action_161 x = happyTcHack x happyFail--action_162 x = happyTcHack x happyReduce_76--action_163 x = happyTcHack x happyReduce_75--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 (70#) = happyShift action_23-action_164 (71#) = happyShift action_24-action_164 (75#) = happyShift action_25-action_164 (77#) = happyShift action_26-action_164 (82#) = happyShift action_27-action_164 (84#) = happyShift action_28-action_164 (86#) = happyShift action_29-action_164 (87#) = happyShift action_30-action_164 (88#) = happyShift action_31-action_164 (6#) = happyGoto action_2-action_164 (7#) = happyGoto action_167-action_164 (9#) = happyGoto action_4-action_164 (14#) = happyGoto action_168-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 (28#) = happyShift action_12-action_165 (29#) = happyShift action_13-action_165 (30#) = happyShift action_14-action_165 (35#) = happyShift action_15-action_165 (42#) = happyShift action_16-action_165 (43#) = happyShift action_17-action_165 (44#) = happyShift action_18-action_165 (50#) = happyShift action_19-action_165 (56#) = happyShift action_20-action_165 (60#) = happyShift action_21-action_165 (61#) = happyShift action_22-action_165 (70#) = happyShift action_23-action_165 (71#) = happyShift action_24-action_165 (75#) = happyShift action_25-action_165 (77#) = happyShift action_26-action_165 (82#) = happyShift action_27-action_165 (84#) = happyShift action_28-action_165 (86#) = happyShift action_29-action_165 (87#) = happyShift action_30-action_165 (88#) = happyShift action_31-action_165 (6#) = happyGoto action_2-action_165 (7#) = happyGoto action_166-action_165 (9#) = happyGoto action_4-action_165 (16#) = happyGoto action_5-action_165 (17#) = happyGoto action_6-action_165 (18#) = happyGoto action_7-action_165 (21#) = happyGoto action_8-action_165 (24#) = happyGoto action_9-action_165 (25#) = happyGoto action_10-action_165 (26#) = happyGoto action_11-action_165 x = happyTcHack x happyFail--action_166 (41#) = happyShift action_36-action_166 (42#) = happyShift action_37-action_166 (43#) = happyShift action_38-action_166 (44#) = happyShift action_39-action_166 (45#) = happyShift action_40-action_166 (46#) = happyShift action_41-action_166 (47#) = happyShift action_42-action_166 (48#) = happyShift action_43-action_166 (49#) = happyShift action_44-action_166 (50#) = happyShift action_45-action_166 (51#) = happyShift action_46-action_166 (52#) = happyShift action_47-action_166 (53#) = happyShift action_48-action_166 (54#) = happyShift action_49-action_166 (55#) = happyShift action_50-action_166 (56#) = happyShift action_51-action_166 (57#) = happyShift action_52-action_166 (58#) = happyShift action_53-action_166 (59#) = happyShift action_54-action_166 x = happyTcHack x happyReduce_8--action_167 (41#) = happyShift action_36-action_167 (42#) = happyShift action_37-action_167 (43#) = happyShift action_38-action_167 (44#) = happyShift action_39-action_167 (45#) = happyShift action_40-action_167 (46#) = happyShift action_41-action_167 (47#) = happyShift action_42-action_167 (48#) = happyShift action_43-action_167 (49#) = happyShift action_44-action_167 (50#) = happyShift action_45-action_167 (51#) = happyShift action_46-action_167 (52#) = happyShift action_47-action_167 (53#) = happyShift action_48-action_167 (54#) = happyShift action_49-action_167 (55#) = happyShift action_50-action_167 (56#) = happyShift action_51-action_167 (57#) = happyShift action_52-action_167 (58#) = happyShift action_53-action_167 (59#) = happyShift action_54-action_167 (68#) = happyShift action_202-action_167 (69#) = happyShift action_203-action_167 (15#) = happyGoto action_201-action_167 x = happyTcHack x happyReduce_62--action_168 (63#) = happyShift action_200-action_168 x = happyTcHack x happyReduce_56--action_169 (52#) = happyShift action_199-action_169 x = happyTcHack x happyFail--action_170 (38#) = happyShift action_198-action_170 (63#) = happyShift action_106-action_170 x = happyTcHack x happyFail--action_171 x = happyTcHack x happyReduce_70--action_172 x = happyTcHack x happyReduce_66--action_173 (33#) = happyShift action_76-action_173 x = happyTcHack x happyReduce_91--action_174 (28#) = happyShift action_12-action_174 (29#) = happyShift action_13-action_174 (30#) = happyShift action_14-action_174 (35#) = happyShift action_15-action_174 (42#) = happyShift action_16-action_174 (43#) = happyShift action_17-action_174 (44#) = happyShift action_18-action_174 (50#) = happyShift action_19-action_174 (56#) = happyShift action_20-action_174 (60#) = happyShift action_21-action_174 (61#) = happyShift action_22-action_174 (70#) = happyShift action_23-action_174 (71#) = happyShift action_24-action_174 (75#) = happyShift action_25-action_174 (77#) = happyShift action_26-action_174 (82#) = happyShift action_27-action_174 (84#) = happyShift action_28-action_174 (86#) = happyShift action_29-action_174 (87#) = happyShift action_30-action_174 (88#) = happyShift action_31-action_174 (6#) = happyGoto action_2-action_174 (7#) = happyGoto action_197-action_174 (9#) = happyGoto action_4-action_174 (16#) = happyGoto action_5-action_174 (17#) = happyGoto action_6-action_174 (18#) = happyGoto action_7-action_174 (21#) = happyGoto action_8-action_174 (24#) = happyGoto action_9-action_174 (25#) = happyGoto action_10-action_174 (26#) = happyGoto action_11-action_174 x = happyTcHack x happyFail--action_175 (84#) = happyShift action_28-action_175 (6#) = happyGoto action_196-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 (70#) = happyShift action_23-action_176 (71#) = happyShift action_24-action_176 (75#) = happyShift action_25-action_176 (77#) = happyShift action_26-action_176 (82#) = happyShift action_27-action_176 (84#) = happyShift action_28-action_176 (86#) = happyShift action_29-action_176 (87#) = happyShift action_30-action_176 (88#) = happyShift action_31-action_176 (6#) = happyGoto action_2-action_176 (7#) = happyGoto action_195-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_193-action_177 (88#) = happyShift action_194-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 (70#) = happyShift action_23-action_178 (71#) = happyShift action_24-action_178 (75#) = happyShift action_25-action_178 (77#) = happyShift action_26-action_178 (82#) = happyShift action_27-action_178 (84#) = happyShift action_28-action_178 (86#) = happyShift action_29-action_178 (87#) = happyShift action_30-action_178 (88#) = happyShift action_31-action_178 (6#) = happyGoto action_2-action_178 (7#) = happyGoto action_192-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_78--action_180 (84#) = happyShift action_28-action_180 (6#) = happyGoto action_191-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 (70#) = happyShift action_23-action_181 (71#) = happyShift action_24-action_181 (75#) = happyShift action_25-action_181 (77#) = happyShift action_26-action_181 (82#) = happyShift action_27-action_181 (84#) = happyShift action_28-action_181 (86#) = happyShift action_29-action_181 (87#) = happyShift action_30-action_181 (88#) = happyShift action_31-action_181 (6#) = happyGoto action_2-action_181 (7#) = happyGoto action_190-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 (28#) = happyShift action_12-action_182 (29#) = happyShift action_13-action_182 (30#) = happyShift action_14-action_182 (35#) = happyShift action_15-action_182 (42#) = happyShift action_16-action_182 (43#) = happyShift action_17-action_182 (44#) = happyShift action_18-action_182 (50#) = happyShift action_19-action_182 (56#) = happyShift action_20-action_182 (60#) = happyShift action_21-action_182 (61#) = happyShift action_22-action_182 (70#) = happyShift action_23-action_182 (71#) = happyShift action_24-action_182 (75#) = happyShift action_25-action_182 (77#) = happyShift action_26-action_182 (82#) = happyShift action_27-action_182 (84#) = happyShift action_28-action_182 (86#) = happyShift action_29-action_182 (87#) = happyShift action_30-action_182 (88#) = happyShift action_31-action_182 (6#) = happyGoto action_2-action_182 (7#) = happyGoto action_189-action_182 (9#) = happyGoto action_4-action_182 (16#) = happyGoto action_5-action_182 (17#) = happyGoto action_6-action_182 (18#) = happyGoto action_7-action_182 (21#) = happyGoto action_8-action_182 (24#) = happyGoto action_9-action_182 (25#) = happyGoto action_10-action_182 (26#) = happyGoto action_11-action_182 x = happyTcHack x happyFail--action_183 (36#) = happyShift action_187-action_183 (63#) = happyShift action_188-action_183 x = happyTcHack x happyFail--action_184 x = happyTcHack x happyReduce_5--action_185 (48#) = happyShift action_186-action_185 x = happyTcHack x happyFail--action_186 (28#) = happyShift action_12-action_186 (29#) = happyShift action_13-action_186 (30#) = happyShift action_14-action_186 (35#) = happyShift action_15-action_186 (42#) = happyShift action_16-action_186 (43#) = happyShift action_17-action_186 (44#) = happyShift action_18-action_186 (50#) = happyShift action_19-action_186 (56#) = happyShift action_20-action_186 (60#) = happyShift action_21-action_186 (61#) = happyShift action_22-action_186 (70#) = happyShift action_23-action_186 (71#) = happyShift action_24-action_186 (75#) = happyShift action_25-action_186 (77#) = happyShift action_26-action_186 (82#) = happyShift action_27-action_186 (84#) = happyShift action_28-action_186 (86#) = happyShift action_29-action_186 (87#) = happyShift action_30-action_186 (88#) = happyShift action_31-action_186 (6#) = happyGoto action_2-action_186 (7#) = happyGoto action_211-action_186 (9#) = happyGoto action_4-action_186 (16#) = happyGoto action_5-action_186 (17#) = happyGoto action_6-action_186 (18#) = happyGoto action_7-action_186 (21#) = happyGoto action_8-action_186 (24#) = happyGoto action_9-action_186 (25#) = happyGoto action_10-action_186 (26#) = happyGoto action_11-action_186 x = happyTcHack x happyFail--action_187 (48#) = happyShift action_210-action_187 x = happyTcHack x happyFail--action_188 (84#) = happyShift action_28-action_188 (6#) = happyGoto action_209-action_188 x = happyTcHack x happyFail--action_189 (41#) = happyShift action_36-action_189 (42#) = happyShift action_37-action_189 (43#) = happyShift action_38-action_189 (44#) = happyShift action_39-action_189 (45#) = happyShift action_40-action_189 (46#) = happyShift action_41-action_189 (47#) = happyShift action_42-action_189 (48#) = happyShift action_43-action_189 (49#) = happyShift action_44-action_189 (50#) = happyShift action_45-action_189 (51#) = happyShift action_46-action_189 (52#) = happyShift action_47-action_189 (53#) = happyShift action_48-action_189 (54#) = happyShift action_49-action_189 (55#) = happyShift action_50-action_189 (56#) = happyShift action_51-action_189 (57#) = happyShift action_52-action_189 (58#) = happyShift action_53-action_189 (59#) = happyShift action_54-action_189 x = happyTcHack x happyReduce_53--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 happyReduce_48--action_191 x = happyTcHack x happyReduce_47--action_192 (40#) = happyShift action_208-action_192 (41#) = happyShift action_36-action_192 (42#) = happyShift action_37-action_192 (43#) = happyShift action_38-action_192 (44#) = happyShift action_39-action_192 (45#) = happyShift action_40-action_192 (46#) = happyShift action_41-action_192 (47#) = happyShift action_42-action_192 (48#) = happyShift action_43-action_192 (49#) = happyShift action_44-action_192 (50#) = happyShift action_45-action_192 (51#) = happyShift action_46-action_192 (52#) = happyShift action_47-action_192 (53#) = happyShift action_48-action_192 (54#) = happyShift action_49-action_192 (55#) = happyShift action_50-action_192 (56#) = happyShift action_51-action_192 (57#) = happyShift action_52-action_192 (58#) = happyShift action_53-action_192 (59#) = happyShift action_54-action_192 x = happyTcHack x happyFail--action_193 (28#) = happyShift action_12-action_193 (29#) = happyShift action_13-action_193 (30#) = happyShift action_14-action_193 (35#) = happyShift action_15-action_193 (42#) = happyShift action_16-action_193 (43#) = happyShift action_17-action_193 (44#) = happyShift action_18-action_193 (50#) = happyShift action_19-action_193 (56#) = happyShift action_20-action_193 (60#) = happyShift action_21-action_193 (61#) = happyShift action_22-action_193 (70#) = happyShift action_23-action_193 (71#) = happyShift action_24-action_193 (75#) = happyShift action_25-action_193 (77#) = happyShift action_26-action_193 (82#) = happyShift action_27-action_193 (84#) = happyShift action_28-action_193 (86#) = happyShift action_29-action_193 (87#) = happyShift action_30-action_193 (88#) = happyShift action_31-action_193 (6#) = happyGoto action_2-action_193 (7#) = happyGoto action_207-action_193 (9#) = happyGoto action_4-action_193 (16#) = happyGoto action_5-action_193 (17#) = happyGoto action_6-action_193 (18#) = happyGoto action_7-action_193 (21#) = happyGoto action_8-action_193 (24#) = happyGoto action_9-action_193 (25#) = happyGoto action_10-action_193 (26#) = happyGoto action_11-action_193 x = happyTcHack x happyFail--action_194 x = happyTcHack x happyReduce_80--action_195 (41#) = happyShift action_36-action_195 (42#) = happyShift action_37-action_195 (43#) = happyShift action_38-action_195 (44#) = happyShift action_39-action_195 (45#) = happyShift action_40-action_195 (46#) = happyShift action_41-action_195 (47#) = happyShift action_42-action_195 (48#) = happyShift action_43-action_195 (49#) = happyShift action_44-action_195 (50#) = happyShift action_45-action_195 (51#) = happyShift action_46-action_195 (52#) = happyShift action_47-action_195 (53#) = happyShift action_48-action_195 (54#) = happyShift action_49-action_195 (55#) = happyShift action_50-action_195 (56#) = happyShift action_51-action_195 (57#) = happyShift action_52-action_195 (58#) = happyShift action_53-action_195 (59#) = happyShift action_54-action_195 x = happyTcHack x happyReduce_11--action_196 (62#) = happyShift action_206-action_196 x = happyTcHack x happyFail--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 (80#) = happyShift action_205-action_197 x = happyTcHack x happyReduce_49--action_198 x = happyTcHack x happyReduce_74--action_199 x = happyTcHack x happyReduce_65--action_200 (28#) = happyShift action_12-action_200 (29#) = happyShift action_13-action_200 (30#) = happyShift action_14-action_200 (35#) = happyShift action_15-action_200 (42#) = happyShift action_16-action_200 (43#) = happyShift action_17-action_200 (44#) = happyShift action_18-action_200 (50#) = happyShift action_19-action_200 (56#) = happyShift action_20-action_200 (60#) = happyShift action_21-action_200 (61#) = happyShift action_22-action_200 (70#) = happyShift action_23-action_200 (71#) = happyShift action_24-action_200 (75#) = happyShift action_25-action_200 (77#) = happyShift action_26-action_200 (82#) = happyShift action_27-action_200 (84#) = happyShift action_28-action_200 (86#) = happyShift action_29-action_200 (87#) = happyShift action_30-action_200 (88#) = happyShift action_31-action_200 (6#) = happyGoto action_2-action_200 (7#) = happyGoto action_204-action_200 (9#) = happyGoto action_4-action_200 (16#) = happyGoto action_5-action_200 (17#) = happyGoto action_6-action_200 (18#) = happyGoto action_7-action_200 (21#) = happyGoto action_8-action_200 (24#) = happyGoto action_9-action_200 (25#) = happyGoto action_10-action_200 (26#) = happyGoto action_11-action_200 x = happyTcHack x happyFail--action_201 x = happyTcHack x happyReduce_58--action_202 x = happyTcHack x happyReduce_60--action_203 x = happyTcHack x happyReduce_61--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 (68#) = happyShift action_202-action_204 (69#) = happyShift action_203-action_204 (15#) = happyGoto action_217-action_204 x = happyTcHack x happyReduce_62--action_205 (84#) = happyShift action_28-action_205 (6#) = happyGoto action_216-action_205 x = happyTcHack x happyFail--action_206 (28#) = happyShift action_12-action_206 (29#) = happyShift action_13-action_206 (30#) = happyShift action_14-action_206 (35#) = happyShift action_15-action_206 (42#) = happyShift action_16-action_206 (43#) = happyShift action_17-action_206 (44#) = happyShift action_18-action_206 (50#) = happyShift action_19-action_206 (56#) = happyShift action_20-action_206 (60#) = happyShift action_21-action_206 (61#) = happyShift action_22-action_206 (70#) = happyShift action_23-action_206 (71#) = happyShift action_24-action_206 (75#) = happyShift action_25-action_206 (77#) = happyShift action_26-action_206 (82#) = happyShift action_27-action_206 (84#) = happyShift action_28-action_206 (86#) = happyShift action_29-action_206 (87#) = happyShift action_30-action_206 (88#) = happyShift action_31-action_206 (6#) = happyGoto action_2-action_206 (7#) = happyGoto action_215-action_206 (9#) = happyGoto action_4-action_206 (16#) = happyGoto action_5-action_206 (17#) = happyGoto action_6-action_206 (18#) = happyGoto action_7-action_206 (21#) = happyGoto action_8-action_206 (24#) = happyGoto action_9-action_206 (25#) = happyGoto action_10-action_206 (26#) = happyGoto action_11-action_206 x = happyTcHack x happyFail--action_207 (40#) = happyShift action_214-action_207 (41#) = happyShift action_36-action_207 (42#) = happyShift action_37-action_207 (43#) = happyShift action_38-action_207 (44#) = happyShift action_39-action_207 (45#) = happyShift action_40-action_207 (46#) = happyShift action_41-action_207 (47#) = happyShift action_42-action_207 (48#) = happyShift action_43-action_207 (49#) = happyShift action_44-action_207 (50#) = happyShift action_45-action_207 (51#) = happyShift action_46-action_207 (52#) = happyShift action_47-action_207 (53#) = happyShift action_48-action_207 (54#) = happyShift action_49-action_207 (55#) = happyShift action_50-action_207 (56#) = happyShift action_51-action_207 (57#) = happyShift action_52-action_207 (58#) = happyShift action_53-action_207 (59#) = happyShift action_54-action_207 x = happyTcHack x happyFail--action_208 x = happyTcHack x happyReduce_79--action_209 x = happyTcHack x happyReduce_6--action_210 (28#) = happyShift action_12-action_210 (29#) = happyShift action_13-action_210 (30#) = happyShift action_14-action_210 (35#) = happyShift action_15-action_210 (42#) = happyShift action_16-action_210 (43#) = happyShift action_17-action_210 (44#) = happyShift action_18-action_210 (50#) = happyShift action_19-action_210 (56#) = happyShift action_20-action_210 (60#) = happyShift action_21-action_210 (61#) = happyShift action_22-action_210 (70#) = happyShift action_23-action_210 (71#) = happyShift action_24-action_210 (75#) = happyShift action_25-action_210 (77#) = happyShift action_26-action_210 (82#) = happyShift action_27-action_210 (84#) = happyShift action_28-action_210 (86#) = happyShift action_29-action_210 (87#) = happyShift action_30-action_210 (88#) = happyShift action_31-action_210 (6#) = happyGoto action_2-action_210 (7#) = happyGoto action_213-action_210 (9#) = happyGoto action_4-action_210 (16#) = happyGoto action_5-action_210 (17#) = happyGoto action_6-action_210 (18#) = happyGoto action_7-action_210 (21#) = happyGoto action_8-action_210 (24#) = happyGoto action_9-action_210 (25#) = happyGoto action_10-action_210 (26#) = happyGoto action_11-action_210 x = happyTcHack x happyFail--action_211 (41#) = happyShift action_36-action_211 (42#) = happyShift action_37-action_211 (43#) = happyShift action_38-action_211 (44#) = happyShift action_39-action_211 (45#) = happyShift action_40-action_211 (46#) = happyShift action_41-action_211 (47#) = happyShift action_42-action_211 (48#) = happyShift action_43-action_211 (49#) = happyShift action_44-action_211 (50#) = happyShift action_45-action_211 (51#) = happyShift action_46-action_211 (52#) = happyShift action_47-action_211 (53#) = happyShift action_48-action_211 (54#) = happyShift action_49-action_211 (55#) = happyShift action_50-action_211 (56#) = happyShift action_51-action_211 (57#) = happyShift action_52-action_211 (58#) = happyShift action_53-action_211 (59#) = happyShift action_54-action_211 (83#) = happyShift action_212-action_211 x = happyTcHack x happyFail--action_212 (28#) = happyShift action_12-action_212 (29#) = happyShift action_13-action_212 (30#) = happyShift action_14-action_212 (35#) = happyShift action_15-action_212 (42#) = happyShift action_16-action_212 (43#) = happyShift action_17-action_212 (44#) = happyShift action_18-action_212 (50#) = happyShift action_19-action_212 (56#) = happyShift action_20-action_212 (60#) = happyShift action_21-action_212 (61#) = happyShift action_22-action_212 (70#) = happyShift action_23-action_212 (71#) = happyShift action_24-action_212 (75#) = happyShift action_25-action_212 (77#) = happyShift action_26-action_212 (78#) = happyShift action_34-action_212 (82#) = happyShift action_27-action_212 (84#) = happyShift action_28-action_212 (86#) = happyShift action_29-action_212 (87#) = happyShift action_30-action_212 (88#) = happyShift action_31-action_212 (4#) = happyGoto action_219-action_212 (6#) = happyGoto action_2-action_212 (7#) = happyGoto action_33-action_212 (9#) = happyGoto action_4-action_212 (16#) = happyGoto action_5-action_212 (17#) = happyGoto action_6-action_212 (18#) = happyGoto action_7-action_212 (21#) = happyGoto action_8-action_212 (24#) = happyGoto action_9-action_212 (25#) = happyGoto action_10-action_212 (26#) = happyGoto action_11-action_212 x = happyTcHack x happyFail--action_213 (41#) = happyShift action_36-action_213 (42#) = happyShift action_37-action_213 (43#) = happyShift action_38-action_213 (44#) = happyShift action_39-action_213 (45#) = happyShift action_40-action_213 (46#) = happyShift action_41-action_213 (47#) = happyShift action_42-action_213 (48#) = happyShift action_43-action_213 (49#) = happyShift action_44-action_213 (50#) = happyShift action_45-action_213 (51#) = happyShift action_46-action_213 (52#) = happyShift action_47-action_213 (53#) = happyShift action_48-action_213 (54#) = happyShift action_49-action_213 (55#) = happyShift action_50-action_213 (56#) = happyShift action_51-action_213 (57#) = happyShift action_52-action_213 (58#) = happyShift action_53-action_213 (59#) = happyShift action_54-action_213 (83#) = happyShift action_218-action_213 x = happyTcHack x happyFail--action_214 x = happyTcHack x happyReduce_81--action_215 (41#) = happyShift action_36-action_215 (42#) = happyShift action_37-action_215 (43#) = happyShift action_38-action_215 (44#) = happyShift action_39-action_215 (45#) = happyShift action_40-action_215 (46#) = happyShift action_41-action_215 (47#) = happyShift action_42-action_215 (48#) = happyShift action_43-action_215 (49#) = happyShift action_44-action_215 (50#) = happyShift action_45-action_215 (51#) = happyShift action_46-action_215 (52#) = happyShift action_47-action_215 (53#) = happyShift action_48-action_215 (54#) = happyShift action_49-action_215 (55#) = happyShift action_50-action_215 (56#) = happyShift action_51-action_215 (57#) = happyShift action_52-action_215 (58#) = happyShift action_53-action_215 (59#) = happyShift action_54-action_215 x = happyTcHack x happyReduce_51--action_216 x = happyTcHack x happyReduce_50--action_217 x = happyTcHack x happyReduce_59--action_218 (28#) = happyShift action_12-action_218 (29#) = happyShift action_13-action_218 (30#) = happyShift action_14-action_218 (35#) = happyShift action_15-action_218 (42#) = happyShift action_16-action_218 (43#) = happyShift action_17-action_218 (44#) = happyShift action_18-action_218 (50#) = happyShift action_19-action_218 (56#) = happyShift action_20-action_218 (60#) = happyShift action_21-action_218 (61#) = happyShift action_22-action_218 (70#) = happyShift action_23-action_218 (71#) = happyShift action_24-action_218 (75#) = happyShift action_25-action_218 (77#) = happyShift action_26-action_218 (78#) = happyShift action_34-action_218 (82#) = happyShift action_27-action_218 (84#) = happyShift action_28-action_218 (86#) = happyShift action_29-action_218 (87#) = happyShift action_30-action_218 (88#) = happyShift action_31-action_218 (4#) = happyGoto action_220-action_218 (6#) = happyGoto action_2-action_218 (7#) = happyGoto action_33-action_218 (9#) = happyGoto action_4-action_218 (16#) = happyGoto action_5-action_218 (17#) = happyGoto action_6-action_218 (18#) = happyGoto action_7-action_218 (21#) = happyGoto action_8-action_218 (24#) = happyGoto action_9-action_218 (25#) = happyGoto action_10-action_218 (26#) = happyGoto action_11-action_218 x = happyTcHack x happyFail--action_219 x = happyTcHack x happyReduce_4--action_220 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 happyOut6 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 -> Ast "for" [happy_var_1,happy_var_3,happy_var_5,x]- ) `HappyStk` happyRest}}}--happyReduce_49 = happyReduce 5# 10# happyReduction_49-happyReduction_49 (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_50 = happyReduce 7# 10# happyReduction_50-happyReduction_50 (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_51 = happyReduce 7# 10# happyReduction_51-happyReduction_51 (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 happyOut6 happy_x_5 of { happy_var_5 -> - case happyOut7 happy_x_7 of { happy_var_7 -> - happyIn10- (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_5,happy_var_7,x])- ) `HappyStk` happyRest}}}}--happyReduce_52 = happySpecReduce_3 11# happyReduction_52-happyReduction_52 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_53 = happyReduce 5# 11# happyReduction_53-happyReduction_53 (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_54 = happySpecReduce_2 12# happyReduction_54-happyReduction_54 happy_x_2- happy_x_1- = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn12- (\x -> Ast "predicate" [happy_var_2,x]- )}--happyReduce_55 = happySpecReduce_0 12# happyReduction_55-happyReduction_55 = happyIn12- (id- )--happyReduce_56 = happySpecReduce_3 13# happyReduction_56-happyReduction_56 happy_x_3- happy_x_2- happy_x_1- = case happyOut14 happy_x_3 of { happy_var_3 -> - happyIn13- ((\x -> Ast "sortTuple" (x:(fst happy_var_3)),- \x -> Ast "sort" (x:(snd happy_var_3)))- )}--happyReduce_57 = happySpecReduce_0 13# happyReduction_57-happyReduction_57 = happyIn13- ((id,id)- )--happyReduce_58 = happySpecReduce_2 14# happyReduction_58-happyReduction_58 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_59 = happyReduce 4# 14# happyReduction_59-happyReduction_59 (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_60 = happySpecReduce_1 15# happyReduction_60-happyReduction_60 happy_x_1- = happyIn15- (Avar "ascending"- )--happyReduce_61 = happySpecReduce_1 15# happyReduction_61-happyReduction_61 happy_x_1- = happyIn15- (Avar "descending"- )--happyReduce_62 = happySpecReduce_0 15# happyReduction_62-happyReduction_62 = happyIn15- (Avar "ascending"- )--happyReduce_63 = happyReduce 4# 16# happyReduction_63-happyReduction_63 (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_64 = happyReduce 4# 16# happyReduction_64-happyReduction_64 (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_65 = happyReduce 6# 17# happyReduction_65-happyReduction_65 (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_66 = happyReduce 5# 17# happyReduction_66-happyReduction_66 (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_67 = happySpecReduce_2 17# happyReduction_67-happyReduction_67 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn17- (Ast "construction" (happy_var_1++[call "empty" []])- )}--happyReduce_68 = happySpecReduce_2 18# happyReduction_68-happyReduction_68 happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { (QName happy_var_2) -> - happyIn18- ([Astring happy_var_2,Ast "attributes" []]- )}--happyReduce_69 = happySpecReduce_3 18# happyReduction_69-happyReduction_69 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_70 = happySpecReduce_3 19# happyReduction_70-happyReduction_70 happy_x_3- happy_x_2- happy_x_1- = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn19- (happy_var_2- )}--happyReduce_71 = happySpecReduce_1 19# happyReduction_71-happyReduction_71 happy_x_1- = case happyOutTok happy_x_1 of { (TString happy_var_1) -> - happyIn19- ([Astring happy_var_1]- )}--happyReduce_72 = happySpecReduce_1 19# happyReduction_72-happyReduction_72 happy_x_1- = case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> - happyIn19- ([Astring happy_var_1]- )}--happyReduce_73 = happySpecReduce_1 19# happyReduction_73-happyReduction_73 happy_x_1- = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn19- ([happy_var_1]- )}--happyReduce_74 = happyReduce 4# 19# happyReduction_74-happyReduction_74 (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_75 = happySpecReduce_2 19# happyReduction_75-happyReduction_75 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_76 = happySpecReduce_2 19# happyReduction_76-happyReduction_76 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_77 = happySpecReduce_2 19# happyReduction_77-happyReduction_77 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_78 = happySpecReduce_3 20# happyReduction_78-happyReduction_78 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_79 = happyReduce 5# 20# happyReduction_79-happyReduction_79 (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_80 = happyReduce 4# 20# happyReduction_80-happyReduction_80 (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- (happy_var_1++[Ast "pair" [Astring happy_var_2,Astring happy_var_4]]- ) `HappyStk` happyRest}}}--happyReduce_81 = happyReduce 6# 20# happyReduction_81-happyReduction_81 (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- (happy_var_1++[Ast "pair" [Astring happy_var_2,happy_var_5]]- ) `HappyStk` happyRest}}}--happyReduce_82 = happySpecReduce_1 21# happyReduction_82-happyReduction_82 happy_x_1- = case happyOut24 happy_x_1 of { happy_var_1 -> - happyIn21- (happy_var_1 "child" (Avar ".")- )}--happyReduce_83 = happySpecReduce_2 21# happyReduction_83-happyReduction_83 happy_x_2- happy_x_1- = case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn21- (happy_var_2 "child_attribute" (Avar ".")- )}--happyReduce_84 = happySpecReduce_2 21# happyReduction_84-happyReduction_84 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_85 = happySpecReduce_3 21# happyReduction_85-happyReduction_85 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 "child_attribute" (Avar "."))- )}}--happyReduce_86 = happySpecReduce_1 22# happyReduction_86-happyReduction_86 happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - happyIn22- (happy_var_1- )}--happyReduce_87 = happySpecReduce_2 22# happyReduction_87-happyReduction_87 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_88 = happySpecReduce_2 23# happyReduction_88-happyReduction_88 happy_x_2- happy_x_1- = case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn23- (\e -> happy_var_2 "child" e- )}--happyReduce_89 = happySpecReduce_3 23# happyReduction_89-happyReduction_89 happy_x_3- happy_x_2- happy_x_1- = case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn23- (\e -> happy_var_3 "child_attribute" e- )}--happyReduce_90 = happySpecReduce_3 23# happyReduction_90-happyReduction_90 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_91 = happyReduce 4# 23# happyReduction_91-happyReduction_91 (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_92 = happySpecReduce_2 23# happyReduction_92-happyReduction_92 happy_x_2- happy_x_1- = happyIn23- (\e -> call "parent" [e]- )--happyReduce_93 = happySpecReduce_1 24# happyReduction_93-happyReduction_93 happy_x_1- = case happyOut25 happy_x_1 of { happy_var_1 -> - happyIn24- (happy_var_1- )}--happyReduce_94 = happyReduce 4# 24# happyReduction_94-happyReduction_94 (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_95 = happySpecReduce_1 25# happyReduction_95-happyReduction_95 happy_x_1- = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn25- (\t e -> happy_var_1 t e- )}--happyReduce_96 = happySpecReduce_1 25# happyReduction_96-happyReduction_96 happy_x_1- = happyIn25- (\t e -> call t [Astring "*",e]- )--happyReduce_97 = happySpecReduce_1 25# happyReduction_97-happyReduction_97 happy_x_1- = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - happyIn25- (\t e -> call t [Astring happy_var_1,e]- )}--happyReduce_98 = happySpecReduce_1 26# happyReduction_98-happyReduction_98 happy_x_1- = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn26- (\_ _ -> happy_var_1- )}--happyReduce_99 = happySpecReduce_1 26# happyReduction_99-happyReduction_99 happy_x_1- = happyIn26- (\_ e -> e- )--happyReduce_100 = happySpecReduce_3 26# happyReduction_100-happyReduction_100 happy_x_3- happy_x_2- happy_x_1- = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn26- (\_ _ -> concatAll happy_var_2- )}--happyReduce_101 = happySpecReduce_2 26# happyReduction_101-happyReduction_101 happy_x_2- happy_x_1- = happyIn26- (\_ _ -> call "empty" []- )--happyReduce_102 = happyReduce 4# 26# happyReduction_102-happyReduction_102 (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_103 = happySpecReduce_3 26# happyReduction_103-happyReduction_103 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 89# 89# 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#;- ORDER -> cont 66#;- BY -> cont 67#;- ASCENDING -> cont 68#;- DESCENDING -> cont 69#;- ELEMENT -> cont 70#;- ATTRIBUTE -> cont 71#;- STAG -> cont 72#;- ETAG -> cont 73#;- SATISFIES -> cont 74#;- ATSIGN -> cont 75#;- SLASH -> cont 76#;- QName happy_dollar_dollar -> cont 77#;- DEFINE -> cont 78#;- FUNCTION -> cont 79#;- AT -> cont 80#;- DOTS -> cont 81#;- DOT -> cont 82#;- SEMI -> cont 83#;- Variable happy_dollar_dollar -> cont 84#;- XMLtext happy_dollar_dollar -> cont 85#;- TInteger happy_dollar_dollar -> cont 86#;- TFloat happy_dollar_dollar -> cont 87#;- TString happy_dollar_dollar -> cont 88#;- _ -> 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 "concatenate" [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 | ORDER | BY | 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 ('\"':'{':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 = 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 = RESCAPE : lexer cs n-lexer ('!':'=':cs) n = TNEQ : lexer cs n-lexer ('\'':cs) n = lexString cs n-lexer ('\"':cs) n = lexString2 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 /= '.'- then TInteger (read k) : lexer rest n- else let (m,rest2) = span isDigit (tail rest)- in TFloat (read (k++('.':m))) : lexer rest2 n- where (k,rest) = span isDigit cs--lexString cs n = TString s : lexer (tail rest) n- where (s,rest) = span inString cs- inString c = c /= '\''--lexString2 cs n = TString s : lexer (tail rest) n- where (s,rest) = span inString cs- inString c = c /= '\"'--lexVar cs n =- case span isQN cs of- ("return",rest) -> RETURN : lexer rest n- ("some",rest) -> SOME : lexer rest n- ("every",rest) -> EVERY : lexer rest n- ("if",rest) -> IF : lexer rest n- ("then",rest) -> THEN : lexer rest n- ("else",rest) -> ELSE : lexer rest n- ("to",rest) -> TO : lexer rest n- ("div",rest) -> DIV : lexer rest n- ("idiv",rest) -> IDIV : lexer rest n- ("mod",rest) -> MOD : lexer rest n- ("and",rest) -> AND : lexer rest n- ("or",rest) -> OR : lexer rest n- ("not",rest) -> NOT : lexer rest n- ("union",rest) -> UNION : lexer rest n- ("intersect",rest) -> INTERSECT : lexer rest n- ("except",rest) -> EXCEPT : lexer rest n- ("for",rest) -> FOR : lexer rest n- ("let",rest) -> LET : lexer rest n- ("in",rest) -> IN : lexer rest n- ("where",rest) -> WHERE : lexer rest n- ("order",rest) -> ORDER : lexer rest n- ("by",rest) -> BY : lexer rest n- ("ascending",rest) -> ASCENDING : lexer rest n- ("descending",rest) -> DESCENDING : lexer rest n- ("element",rest) -> ELEMENT : lexer rest n- ("attribute",rest) -> ATTRIBUTE : lexer rest n- ("satisfies",rest) -> SATISFIES : lexer rest n- ("define",rest) -> DEFINE : lexer rest n- ("function",rest) -> FUNCTION : lexer rest n- ("at",rest) -> AT : lexer rest n- (var,rest) -> QName var : lexer rest n-{-# LINE 1 "GenericTemplate.hs" #-}-{-# LINE 1 "<built-in>" #-}-{-# LINE 1 "<command line>" #-}-{-# LINE 1 "GenericTemplate.hs" #-}--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp --{-# LINE 28 "GenericTemplate.hs" #-}---------{-# LINE 49 "GenericTemplate.hs" #-}--{-# LINE 59 "GenericTemplate.hs" #-}--{-# LINE 68 "GenericTemplate.hs" #-}--infixr 9 `HappyStk`-data HappyStk a = HappyStk a (HappyStk a)---------------------------------------------------------------------------------- starting the parse--happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll---------------------------------------------------------------------------------- Accepting the parse---- If the current token is 1#, it means we've just accepted a partial--- parse (a %partial parser). We must ignore the saved token on the top of--- the stack in this case.-happyAccept 1# tk st sts (_ `HappyStk` ans `HappyStk` _) =- happyReturn1 ans-happyAccept j tk st sts (HappyStk ans _) = - (happyTcHack j ) (happyReturn1 ans)---------------------------------------------------------------------------------- Arrays only: do the next action--{-# LINE 155 "GenericTemplate.hs" #-}---------------------------------------------------------------------------------- HappyState data type (not arrays)----newtype HappyState b c = HappyState- (Int# -> -- token number- Int# -> -- token number (yes, again)- b -> -- token semantic value- HappyState b c -> -- current state- [HappyState b c] -> -- state stack- c)------------------------------------------------------------------------------------ Shifting a token--happyShift new_state 1# tk st sts stk@(x `HappyStk` _) =- let i = (case unsafeCoerce# x of { (I# (i)) -> i }) in--- trace "shifting the error token" $- new_state i i tk (HappyState (new_state)) ((st):(sts)) (stk)--happyShift new_state i tk st sts stk =- happyNewToken new_state ((st):(sts)) ((happyInTok (tk))`HappyStk`stk)---- happyReduce is specialised for the common cases.--happySpecReduce_0 i fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happySpecReduce_0 nt fn j tk st@((HappyState (action))) sts stk- = action nt j tk st ((st):(sts)) (fn `HappyStk` stk)--happySpecReduce_1 i fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happySpecReduce_1 nt fn j tk _ sts@(((st@(HappyState (action))):(_))) (v1`HappyStk`stk')- = let r = fn v1 in- happySeq r (action nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_2 i fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happySpecReduce_2 nt fn j tk _ ((_):(sts@(((st@(HappyState (action))):(_))))) (v1`HappyStk`v2`HappyStk`stk')- = let r = fn v1 v2 in- happySeq r (action nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_3 i fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happySpecReduce_3 nt fn j tk _ ((_):(((_):(sts@(((st@(HappyState (action))):(_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')- = let r = fn v1 v2 v3 in- happySeq r (action nt j tk st sts (r `HappyStk` stk'))--happyReduce k i fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happyReduce k nt fn j tk st sts stk- = case happyDrop (k -# (1# :: Int#)) sts of- sts1@(((st1@(HappyState (action))):(_))) ->- let r = fn stk in -- it doesn't hurt to always seq here...- happyDoSeq r (action nt j tk st1 sts1 r)--happyMonadReduce k nt fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happyMonadReduce k nt fn j tk st sts stk =- happyThen1 (fn stk tk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk))- where sts1@(((st1@(HappyState (action))):(_))) = happyDrop k ((st):(sts))- drop_stk = happyDropStk k stk--happyMonad2Reduce k nt fn 1# tk st sts stk- = happyFail 1# tk st sts stk-happyMonad2Reduce k nt fn j tk st sts stk =- happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))- where sts1@(((st1@(HappyState (action))):(_))) = happyDrop k ((st):(sts))- drop_stk = happyDropStk k stk------ new_state = action---happyDrop 0# l = l-happyDrop n ((_):(t)) = happyDrop (n -# (1# :: Int#)) t--happyDropStk 0# l = l-happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::Int#)) xs---------------------------------------------------------------------------------- Moving to a new state after a reduction--{-# LINE 253 "GenericTemplate.hs" #-}-happyGoto action j tk st = action j j tk (HappyState action)----------------------------------------------------------------------------------- Error recovery (1# is the error token)---- parse error if we are in recovery and we fail again-happyFail 1# tk old_st _ stk =--- trace "failing" $ - happyError_ tk--{- We don't need state discarding for our restricted implementation of- "error". In fact, it can cause some bogus parses, so I've disabled it- for now --SDM---- discard a state-happyFail 1# tk old_st (((HappyState (action))):(sts)) - (saved_tok `HappyStk` _ `HappyStk` stk) =--- trace ("discarding state, depth " ++ show (length stk)) $- action 1# 1# tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))--}---- Enter error recovery: generate an error token,--- save the old token and carry on.-happyFail i tk (HappyState (action)) sts stk =--- trace "entering error recovery" $- action 1# 1# tk (HappyState (action)) sts ( (unsafeCoerce# (I# (i))) `HappyStk` stk)---- Internal happy errors:--notHappyAtAll = error "Internal Happy error\n"---------------------------------------------------------------------------------- Hack to get the typechecker to accept our action functions---happyTcHack :: Int# -> a -> a-happyTcHack x y = y-{-# INLINE happyTcHack #-}----------------------------------------------------------------------------------- Seq-ing. If the --strict flag is given, then Happy emits --- happySeq = happyDoSeq--- otherwise it emits--- happySeq = happyDontSeq--happyDoSeq, happyDontSeq :: a -> b -> b-happyDoSeq a b = a `seq` b-happyDontSeq a b = b---------------------------------------------------------------------------------- Don't inline any functions from the template. GHC has a nasty habit--- of deciding to inline happyGoto everywhere, which increases the size of--- the generated parser quite a bit.--{-# LINE 317 "GenericTemplate.hs" #-}+-- 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 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 (65#) = happyShift action_20+action_0 (69#) = happyShift action_21+action_0 (70#) = happyShift action_22+action_0 (79#) = happyShift action_23+action_0 (80#) = happyShift action_24+action_0 (84#) = happyShift action_25+action_0 (86#) = happyShift action_26+action_0 (87#) = happyShift action_34+action_0 (92#) = happyShift action_27+action_0 (94#) = happyShift action_28+action_0 (96#) = happyShift action_29+action_0 (97#) = happyShift action_30+action_0 (98#) = 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 (65#) = happyShift action_20+action_1 (69#) = happyShift action_21+action_1 (70#) = happyShift action_22+action_1 (79#) = happyShift action_23+action_1 (80#) = happyShift action_24+action_1 (84#) = happyShift action_25+action_1 (86#) = happyShift action_26+action_1 (92#) = happyShift action_27+action_1 (94#) = happyShift action_28+action_1 (96#) = happyShift action_29+action_1 (97#) = happyShift action_30+action_1 (98#) = 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_110++action_3 (41#) = happyShift action_37+action_3 (42#) = happyShift action_38+action_3 (43#) = happyShift action_39+action_3 (44#) = happyShift action_40+action_3 (45#) = happyShift action_41+action_3 (46#) = happyShift action_42+action_3 (47#) = happyShift action_43+action_3 (48#) = happyShift action_44+action_3 (49#) = happyShift action_45+action_3 (50#) = happyShift action_46+action_3 (51#) = happyShift action_47+action_3 (52#) = happyShift action_48+action_3 (53#) = happyShift action_49+action_3 (54#) = happyShift action_50+action_3 (55#) = happyShift action_51+action_3 (56#) = happyShift action_52+action_3 (57#) = happyShift action_53+action_3 (58#) = happyShift action_54+action_3 (59#) = happyShift action_55+action_3 (60#) = happyShift action_56+action_3 (61#) = happyShift action_57+action_3 (62#) = happyShift action_58+action_3 (63#) = happyShift action_59+action_3 (64#) = happyShift action_60+action_3 (65#) = happyShift action_61+action_3 (66#) = happyShift action_62+action_3 (67#) = happyShift action_63+action_3 (68#) = happyShift action_64+action_3 x = happyTcHack x happyFail++action_4 (69#) = happyShift action_95+action_4 (70#) = happyShift action_96+action_4 (74#) = happyShift action_97+action_4 (12#) = happyGoto action_94+action_4 x = happyTcHack x happyReduce_63++action_5 x = happyTcHack x happyReduce_15++action_6 x = happyTcHack x happyReduce_14++action_7 (52#) = happyShift action_92+action_7 (82#) = happyShift action_93+action_7 x = happyTcHack x happyFail++action_8 x = happyTcHack x happyReduce_13++action_9 (33#) = happyShift action_90+action_9 (85#) = happyShift action_91+action_9 (22#) = happyGoto action_88+action_9 (23#) = happyGoto action_89+action_9 x = happyTcHack x happyReduce_94++action_10 x = happyTcHack x happyReduce_105++action_11 x = happyTcHack x happyReduce_107++action_12 (94#) = happyShift action_28+action_12 (6#) = happyGoto action_76+action_12 (10#) = happyGoto action_87+action_12 x = happyTcHack x happyFail++action_13 (94#) = happyShift action_28+action_13 (6#) = happyGoto action_76+action_13 (10#) = happyGoto action_86+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 (65#) = happyShift action_20+action_14 (69#) = happyShift action_21+action_14 (70#) = happyShift action_22+action_14 (79#) = happyShift action_23+action_14 (80#) = happyShift action_24+action_14 (84#) = happyShift action_25+action_14 (86#) = happyShift action_26+action_14 (92#) = happyShift action_27+action_14 (94#) = happyShift action_28+action_14 (96#) = happyShift action_29+action_14 (97#) = happyShift action_30+action_14 (98#) = happyShift action_31+action_14 (6#) = happyGoto action_2+action_14 (7#) = happyGoto action_85+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_84+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 (65#) = happyShift action_20+action_15 (69#) = happyShift action_21+action_15 (70#) = happyShift action_22+action_15 (79#) = happyShift action_23+action_15 (80#) = happyShift action_24+action_15 (84#) = happyShift action_25+action_15 (86#) = happyShift action_26+action_15 (92#) = happyShift action_27+action_15 (94#) = happyShift action_28+action_15 (96#) = happyShift action_29+action_15 (97#) = happyShift action_30+action_15 (98#) = happyShift action_31+action_15 (6#) = happyGoto action_2+action_15 (7#) = happyGoto action_82+action_15 (8#) = happyGoto action_83+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 (65#) = happyShift action_20+action_16 (69#) = happyShift action_21+action_16 (70#) = happyShift action_22+action_16 (79#) = happyShift action_23+action_16 (80#) = happyShift action_24+action_16 (84#) = happyShift action_25+action_16 (86#) = happyShift action_26+action_16 (92#) = happyShift action_27+action_16 (94#) = happyShift action_28+action_16 (96#) = happyShift action_29+action_16 (97#) = happyShift action_30+action_16 (98#) = happyShift action_31+action_16 (6#) = happyGoto action_2+action_16 (7#) = happyGoto action_81+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 (65#) = happyShift action_20+action_17 (69#) = happyShift action_21+action_17 (70#) = happyShift action_22+action_17 (79#) = happyShift action_23+action_17 (80#) = happyShift action_24+action_17 (84#) = happyShift action_25+action_17 (86#) = happyShift action_26+action_17 (92#) = happyShift action_27+action_17 (94#) = happyShift action_28+action_17 (96#) = happyShift action_29+action_17 (97#) = happyShift action_30+action_17 (98#) = happyShift action_31+action_17 (6#) = happyGoto action_2+action_17 (7#) = happyGoto action_80+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_108++action_19 (86#) = happyShift action_79+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 (65#) = happyShift action_20+action_20 (69#) = happyShift action_21+action_20 (70#) = happyShift action_22+action_20 (79#) = happyShift action_23+action_20 (80#) = happyShift action_24+action_20 (84#) = happyShift action_25+action_20 (86#) = happyShift action_26+action_20 (92#) = happyShift action_27+action_20 (94#) = happyShift action_28+action_20 (96#) = happyShift action_29+action_20 (97#) = happyShift action_30+action_20 (98#) = happyShift action_31+action_20 (6#) = happyGoto action_2+action_20 (7#) = happyGoto action_78+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 (94#) = happyShift action_28+action_21 (6#) = happyGoto action_76+action_21 (10#) = happyGoto action_77+action_21 x = happyTcHack x happyFail++action_22 (94#) = happyShift action_28+action_22 (6#) = happyGoto action_74+action_22 (11#) = happyGoto action_75+action_22 x = happyTcHack x happyFail++action_23 (35#) = happyShift action_71+action_23 (37#) = happyShift action_72+action_23 (86#) = happyShift action_73+action_23 x = happyTcHack x happyFail++action_24 (35#) = happyShift action_68+action_24 (37#) = happyShift action_69+action_24 (86#) = happyShift action_70+action_24 x = happyTcHack x happyFail++action_25 (35#) = happyShift action_15+action_25 (44#) = happyShift action_18+action_25 (86#) = happyShift action_26+action_25 (92#) = happyShift action_27+action_25 (94#) = happyShift action_28+action_25 (6#) = happyGoto action_2+action_25 (24#) = happyGoto action_67+action_25 (25#) = happyGoto action_10+action_25 (26#) = happyGoto action_11+action_25 x = happyTcHack x happyFail++action_26 (35#) = happyShift action_66+action_26 x = happyTcHack x happyReduce_109++action_27 x = happyTcHack x happyReduce_111++action_28 x = happyTcHack x happyReduce_8++action_29 x = happyTcHack x happyReduce_48++action_30 x = happyTcHack x happyReduce_49++action_31 x = happyTcHack x happyReduce_47++action_32 (99#) = happyAccept+action_32 x = happyTcHack x happyFail++action_33 (41#) = happyShift action_37+action_33 (42#) = happyShift action_38+action_33 (43#) = happyShift action_39+action_33 (44#) = happyShift action_40+action_33 (45#) = happyShift action_41+action_33 (46#) = happyShift action_42+action_33 (47#) = happyShift action_43+action_33 (48#) = happyShift action_44+action_33 (49#) = happyShift action_45+action_33 (50#) = happyShift action_46+action_33 (51#) = happyShift action_47+action_33 (52#) = happyShift action_48+action_33 (53#) = happyShift action_49+action_33 (54#) = happyShift action_50+action_33 (55#) = happyShift action_51+action_33 (56#) = happyShift action_52+action_33 (57#) = happyShift action_53+action_33 (58#) = happyShift action_54+action_33 (59#) = happyShift action_55+action_33 (60#) = happyShift action_56+action_33 (61#) = happyShift action_57+action_33 (62#) = happyShift action_58+action_33 (63#) = happyShift action_59+action_33 (64#) = happyShift action_60+action_33 (65#) = happyShift action_61+action_33 (66#) = happyShift action_62+action_33 (67#) = happyShift action_63+action_33 (68#) = happyShift action_64+action_33 (95#) = happyShift action_65+action_33 x = happyTcHack x happyReduce_1++action_34 (88#) = happyShift action_35+action_34 (89#) = happyShift action_36+action_34 x = happyTcHack x happyFail++action_35 (86#) = happyShift action_167+action_35 x = happyTcHack x happyFail++action_36 (94#) = happyShift action_28+action_36 (6#) = happyGoto action_166+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 (65#) = happyShift action_20+action_37 (69#) = happyShift action_21+action_37 (70#) = happyShift action_22+action_37 (79#) = happyShift action_23+action_37 (80#) = happyShift action_24+action_37 (84#) = happyShift action_25+action_37 (86#) = happyShift action_26+action_37 (92#) = happyShift action_27+action_37 (94#) = happyShift action_28+action_37 (96#) = happyShift action_29+action_37 (97#) = happyShift action_30+action_37 (98#) = happyShift action_31+action_37 (6#) = happyGoto action_2+action_37 (7#) = happyGoto action_165+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 (65#) = happyShift action_20+action_38 (69#) = happyShift action_21+action_38 (70#) = happyShift action_22+action_38 (79#) = happyShift action_23+action_38 (80#) = happyShift action_24+action_38 (84#) = happyShift action_25+action_38 (86#) = happyShift action_26+action_38 (92#) = happyShift action_27+action_38 (94#) = happyShift action_28+action_38 (96#) = happyShift action_29+action_38 (97#) = happyShift action_30+action_38 (98#) = happyShift action_31+action_38 (6#) = happyGoto action_2+action_38 (7#) = happyGoto action_164+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 (65#) = happyShift action_20+action_39 (69#) = happyShift action_21+action_39 (70#) = happyShift action_22+action_39 (79#) = happyShift action_23+action_39 (80#) = happyShift action_24+action_39 (84#) = happyShift action_25+action_39 (86#) = happyShift action_26+action_39 (92#) = happyShift action_27+action_39 (94#) = happyShift action_28+action_39 (96#) = happyShift action_29+action_39 (97#) = happyShift action_30+action_39 (98#) = happyShift action_31+action_39 (6#) = happyGoto action_2+action_39 (7#) = happyGoto action_163+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 (65#) = happyShift action_20+action_40 (69#) = happyShift action_21+action_40 (70#) = happyShift action_22+action_40 (79#) = happyShift action_23+action_40 (80#) = happyShift action_24+action_40 (84#) = happyShift action_25+action_40 (86#) = happyShift action_26+action_40 (92#) = happyShift action_27+action_40 (94#) = happyShift action_28+action_40 (96#) = happyShift action_29+action_40 (97#) = happyShift action_30+action_40 (98#) = happyShift action_31+action_40 (6#) = happyGoto action_2+action_40 (7#) = happyGoto action_162+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 (65#) = happyShift action_20+action_41 (69#) = happyShift action_21+action_41 (70#) = happyShift action_22+action_41 (79#) = happyShift action_23+action_41 (80#) = happyShift action_24+action_41 (84#) = happyShift action_25+action_41 (86#) = happyShift action_26+action_41 (92#) = happyShift action_27+action_41 (94#) = happyShift action_28+action_41 (96#) = happyShift action_29+action_41 (97#) = happyShift action_30+action_41 (98#) = happyShift action_31+action_41 (6#) = happyGoto action_2+action_41 (7#) = happyGoto action_161+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 (65#) = happyShift action_20+action_42 (69#) = happyShift action_21+action_42 (70#) = happyShift action_22+action_42 (79#) = happyShift action_23+action_42 (80#) = happyShift action_24+action_42 (84#) = happyShift action_25+action_42 (86#) = happyShift action_26+action_42 (92#) = happyShift action_27+action_42 (94#) = happyShift action_28+action_42 (96#) = happyShift action_29+action_42 (97#) = happyShift action_30+action_42 (98#) = happyShift action_31+action_42 (6#) = happyGoto action_2+action_42 (7#) = happyGoto action_160+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 (65#) = happyShift action_20+action_43 (69#) = happyShift action_21+action_43 (70#) = happyShift action_22+action_43 (79#) = happyShift action_23+action_43 (80#) = happyShift action_24+action_43 (84#) = happyShift action_25+action_43 (86#) = happyShift action_26+action_43 (92#) = happyShift action_27+action_43 (94#) = happyShift action_28+action_43 (96#) = happyShift action_29+action_43 (97#) = happyShift action_30+action_43 (98#) = happyShift action_31+action_43 (6#) = happyGoto action_2+action_43 (7#) = happyGoto action_159+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 (65#) = happyShift action_20+action_44 (69#) = happyShift action_21+action_44 (70#) = happyShift action_22+action_44 (79#) = happyShift action_23+action_44 (80#) = happyShift action_24+action_44 (84#) = happyShift action_25+action_44 (86#) = happyShift action_26+action_44 (92#) = happyShift action_27+action_44 (94#) = happyShift action_28+action_44 (96#) = happyShift action_29+action_44 (97#) = happyShift action_30+action_44 (98#) = happyShift action_31+action_44 (6#) = happyGoto action_2+action_44 (7#) = happyGoto action_158+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 (65#) = happyShift action_20+action_45 (69#) = happyShift action_21+action_45 (70#) = happyShift action_22+action_45 (79#) = happyShift action_23+action_45 (80#) = happyShift action_24+action_45 (84#) = happyShift action_25+action_45 (86#) = happyShift action_26+action_45 (92#) = happyShift action_27+action_45 (94#) = happyShift action_28+action_45 (96#) = happyShift action_29+action_45 (97#) = happyShift action_30+action_45 (98#) = happyShift action_31+action_45 (6#) = happyGoto action_2+action_45 (7#) = happyGoto action_157+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 (65#) = happyShift action_20+action_46 (69#) = happyShift action_21+action_46 (70#) = happyShift action_22+action_46 (79#) = happyShift action_23+action_46 (80#) = happyShift action_24+action_46 (84#) = happyShift action_25+action_46 (86#) = happyShift action_26+action_46 (92#) = happyShift action_27+action_46 (94#) = happyShift action_28+action_46 (96#) = happyShift action_29+action_46 (97#) = happyShift action_30+action_46 (98#) = happyShift action_31+action_46 (6#) = happyGoto action_2+action_46 (7#) = happyGoto action_156+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 (65#) = happyShift action_20+action_47 (69#) = happyShift action_21+action_47 (70#) = happyShift action_22+action_47 (79#) = happyShift action_23+action_47 (80#) = happyShift action_24+action_47 (84#) = happyShift action_25+action_47 (86#) = happyShift action_26+action_47 (92#) = happyShift action_27+action_47 (94#) = happyShift action_28+action_47 (96#) = happyShift action_29+action_47 (97#) = happyShift action_30+action_47 (98#) = happyShift action_31+action_47 (6#) = happyGoto action_2+action_47 (7#) = happyGoto action_155+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 (65#) = happyShift action_20+action_48 (69#) = happyShift action_21+action_48 (70#) = happyShift action_22+action_48 (79#) = happyShift action_23+action_48 (80#) = happyShift action_24+action_48 (84#) = happyShift action_25+action_48 (86#) = happyShift action_26+action_48 (92#) = happyShift action_27+action_48 (94#) = happyShift action_28+action_48 (96#) = happyShift action_29+action_48 (97#) = happyShift action_30+action_48 (98#) = happyShift action_31+action_48 (6#) = happyGoto action_2+action_48 (7#) = happyGoto action_154+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 (65#) = happyShift action_20+action_49 (69#) = happyShift action_21+action_49 (70#) = happyShift action_22+action_49 (79#) = happyShift action_23+action_49 (80#) = happyShift action_24+action_49 (84#) = happyShift action_25+action_49 (86#) = happyShift action_26+action_49 (92#) = happyShift action_27+action_49 (94#) = happyShift action_28+action_49 (96#) = happyShift action_29+action_49 (97#) = happyShift action_30+action_49 (98#) = happyShift action_31+action_49 (6#) = happyGoto action_2+action_49 (7#) = happyGoto action_153+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 (65#) = happyShift action_20+action_50 (69#) = happyShift action_21+action_50 (70#) = happyShift action_22+action_50 (79#) = happyShift action_23+action_50 (80#) = happyShift action_24+action_50 (84#) = happyShift action_25+action_50 (86#) = happyShift action_26+action_50 (92#) = happyShift action_27+action_50 (94#) = happyShift action_28+action_50 (96#) = happyShift action_29+action_50 (97#) = happyShift action_30+action_50 (98#) = happyShift action_31+action_50 (6#) = happyGoto action_2+action_50 (7#) = happyGoto action_152+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 (65#) = happyShift action_20+action_51 (69#) = happyShift action_21+action_51 (70#) = happyShift action_22+action_51 (79#) = happyShift action_23+action_51 (80#) = happyShift action_24+action_51 (84#) = happyShift action_25+action_51 (86#) = happyShift action_26+action_51 (92#) = happyShift action_27+action_51 (94#) = happyShift action_28+action_51 (96#) = happyShift action_29+action_51 (97#) = happyShift action_30+action_51 (98#) = happyShift action_31+action_51 (6#) = happyGoto action_2+action_51 (7#) = happyGoto action_151+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 (65#) = happyShift action_20+action_52 (69#) = happyShift action_21+action_52 (70#) = happyShift action_22+action_52 (79#) = happyShift action_23+action_52 (80#) = happyShift action_24+action_52 (84#) = happyShift action_25+action_52 (86#) = happyShift action_26+action_52 (92#) = happyShift action_27+action_52 (94#) = happyShift action_28+action_52 (96#) = happyShift action_29+action_52 (97#) = happyShift action_30+action_52 (98#) = happyShift action_31+action_52 (6#) = happyGoto action_2+action_52 (7#) = happyGoto action_150+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 (65#) = happyShift action_20+action_53 (69#) = happyShift action_21+action_53 (70#) = happyShift action_22+action_53 (79#) = happyShift action_23+action_53 (80#) = happyShift action_24+action_53 (84#) = happyShift action_25+action_53 (86#) = happyShift action_26+action_53 (92#) = happyShift action_27+action_53 (94#) = happyShift action_28+action_53 (96#) = happyShift action_29+action_53 (97#) = happyShift action_30+action_53 (98#) = happyShift action_31+action_53 (6#) = happyGoto action_2+action_53 (7#) = happyGoto action_149+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 (65#) = happyShift action_20+action_54 (69#) = happyShift action_21+action_54 (70#) = happyShift action_22+action_54 (79#) = happyShift action_23+action_54 (80#) = happyShift action_24+action_54 (84#) = happyShift action_25+action_54 (86#) = happyShift action_26+action_54 (92#) = happyShift action_27+action_54 (94#) = happyShift action_28+action_54 (96#) = happyShift action_29+action_54 (97#) = happyShift action_30+action_54 (98#) = happyShift action_31+action_54 (6#) = happyGoto action_2+action_54 (7#) = happyGoto action_148+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 (28#) = happyShift action_12+action_55 (29#) = happyShift action_13+action_55 (30#) = happyShift action_14+action_55 (35#) = happyShift action_15+action_55 (42#) = happyShift action_16+action_55 (43#) = happyShift action_17+action_55 (44#) = happyShift action_18+action_55 (50#) = happyShift action_19+action_55 (65#) = happyShift action_20+action_55 (69#) = happyShift action_21+action_55 (70#) = happyShift action_22+action_55 (79#) = happyShift action_23+action_55 (80#) = happyShift action_24+action_55 (84#) = happyShift action_25+action_55 (86#) = happyShift action_26+action_55 (92#) = happyShift action_27+action_55 (94#) = happyShift action_28+action_55 (96#) = happyShift action_29+action_55 (97#) = happyShift action_30+action_55 (98#) = happyShift action_31+action_55 (6#) = happyGoto action_2+action_55 (7#) = happyGoto action_147+action_55 (9#) = happyGoto action_4+action_55 (16#) = happyGoto action_5+action_55 (17#) = happyGoto action_6+action_55 (18#) = happyGoto action_7+action_55 (21#) = happyGoto action_8+action_55 (24#) = happyGoto action_9+action_55 (25#) = happyGoto action_10+action_55 (26#) = happyGoto action_11+action_55 x = happyTcHack x happyFail++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 (42#) = happyShift action_16+action_56 (43#) = happyShift action_17+action_56 (44#) = happyShift action_18+action_56 (50#) = happyShift action_19+action_56 (65#) = happyShift action_20+action_56 (69#) = happyShift action_21+action_56 (70#) = happyShift action_22+action_56 (79#) = happyShift action_23+action_56 (80#) = happyShift action_24+action_56 (84#) = happyShift action_25+action_56 (86#) = happyShift action_26+action_56 (92#) = happyShift action_27+action_56 (94#) = happyShift action_28+action_56 (96#) = happyShift action_29+action_56 (97#) = happyShift action_30+action_56 (98#) = happyShift action_31+action_56 (6#) = happyGoto action_2+action_56 (7#) = happyGoto action_146+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 (28#) = happyShift action_12+action_57 (29#) = happyShift action_13+action_57 (30#) = happyShift action_14+action_57 (35#) = happyShift action_15+action_57 (42#) = happyShift action_16+action_57 (43#) = happyShift action_17+action_57 (44#) = happyShift action_18+action_57 (50#) = happyShift action_19+action_57 (65#) = happyShift action_20+action_57 (69#) = happyShift action_21+action_57 (70#) = happyShift action_22+action_57 (79#) = happyShift action_23+action_57 (80#) = happyShift action_24+action_57 (84#) = happyShift action_25+action_57 (86#) = happyShift action_26+action_57 (92#) = happyShift action_27+action_57 (94#) = happyShift action_28+action_57 (96#) = happyShift action_29+action_57 (97#) = happyShift action_30+action_57 (98#) = happyShift action_31+action_57 (6#) = happyGoto action_2+action_57 (7#) = happyGoto action_145+action_57 (9#) = happyGoto action_4+action_57 (16#) = happyGoto action_5+action_57 (17#) = happyGoto action_6+action_57 (18#) = happyGoto action_7+action_57 (21#) = happyGoto action_8+action_57 (24#) = happyGoto action_9+action_57 (25#) = happyGoto action_10+action_57 (26#) = happyGoto action_11+action_57 x = happyTcHack x happyFail++action_58 (28#) = happyShift action_12+action_58 (29#) = happyShift action_13+action_58 (30#) = happyShift action_14+action_58 (35#) = happyShift action_15+action_58 (42#) = happyShift action_16+action_58 (43#) = happyShift action_17+action_58 (44#) = happyShift action_18+action_58 (50#) = happyShift action_19+action_58 (65#) = happyShift action_20+action_58 (69#) = happyShift action_21+action_58 (70#) = happyShift action_22+action_58 (79#) = happyShift action_23+action_58 (80#) = happyShift action_24+action_58 (84#) = happyShift action_25+action_58 (86#) = happyShift action_26+action_58 (92#) = happyShift action_27+action_58 (94#) = happyShift action_28+action_58 (96#) = happyShift action_29+action_58 (97#) = happyShift action_30+action_58 (98#) = happyShift action_31+action_58 (6#) = happyGoto action_2+action_58 (7#) = happyGoto action_144+action_58 (9#) = happyGoto action_4+action_58 (16#) = happyGoto action_5+action_58 (17#) = happyGoto action_6+action_58 (18#) = happyGoto action_7+action_58 (21#) = happyGoto action_8+action_58 (24#) = happyGoto action_9+action_58 (25#) = happyGoto action_10+action_58 (26#) = happyGoto action_11+action_58 x = happyTcHack x happyFail++action_59 (28#) = happyShift action_12+action_59 (29#) = happyShift action_13+action_59 (30#) = happyShift action_14+action_59 (35#) = happyShift action_15+action_59 (42#) = happyShift action_16+action_59 (43#) = happyShift action_17+action_59 (44#) = happyShift action_18+action_59 (50#) = happyShift action_19+action_59 (65#) = happyShift action_20+action_59 (69#) = happyShift action_21+action_59 (70#) = happyShift action_22+action_59 (79#) = happyShift action_23+action_59 (80#) = happyShift action_24+action_59 (84#) = happyShift action_25+action_59 (86#) = happyShift action_26+action_59 (92#) = happyShift action_27+action_59 (94#) = happyShift action_28+action_59 (96#) = happyShift action_29+action_59 (97#) = happyShift action_30+action_59 (98#) = happyShift action_31+action_59 (6#) = happyGoto action_2+action_59 (7#) = happyGoto action_143+action_59 (9#) = happyGoto action_4+action_59 (16#) = happyGoto action_5+action_59 (17#) = happyGoto action_6+action_59 (18#) = happyGoto action_7+action_59 (21#) = happyGoto action_8+action_59 (24#) = happyGoto action_9+action_59 (25#) = happyGoto action_10+action_59 (26#) = happyGoto action_11+action_59 x = happyTcHack x happyFail++action_60 (28#) = happyShift action_12+action_60 (29#) = happyShift action_13+action_60 (30#) = happyShift action_14+action_60 (35#) = happyShift action_15+action_60 (42#) = happyShift action_16+action_60 (43#) = happyShift action_17+action_60 (44#) = happyShift action_18+action_60 (50#) = happyShift action_19+action_60 (65#) = happyShift action_20+action_60 (69#) = happyShift action_21+action_60 (70#) = happyShift action_22+action_60 (79#) = happyShift action_23+action_60 (80#) = happyShift action_24+action_60 (84#) = happyShift action_25+action_60 (86#) = happyShift action_26+action_60 (92#) = happyShift action_27+action_60 (94#) = happyShift action_28+action_60 (96#) = happyShift action_29+action_60 (97#) = happyShift action_30+action_60 (98#) = happyShift action_31+action_60 (6#) = happyGoto action_2+action_60 (7#) = happyGoto action_142+action_60 (9#) = happyGoto action_4+action_60 (16#) = happyGoto action_5+action_60 (17#) = happyGoto action_6+action_60 (18#) = happyGoto action_7+action_60 (21#) = happyGoto action_8+action_60 (24#) = happyGoto action_9+action_60 (25#) = happyGoto action_10+action_60 (26#) = happyGoto action_11+action_60 x = happyTcHack x happyFail++action_61 (28#) = happyShift action_12+action_61 (29#) = happyShift action_13+action_61 (30#) = happyShift action_14+action_61 (35#) = happyShift action_15+action_61 (42#) = happyShift action_16+action_61 (43#) = happyShift action_17+action_61 (44#) = happyShift action_18+action_61 (50#) = happyShift action_19+action_61 (65#) = happyShift action_20+action_61 (69#) = happyShift action_21+action_61 (70#) = happyShift action_22+action_61 (79#) = happyShift action_23+action_61 (80#) = happyShift action_24+action_61 (84#) = happyShift action_25+action_61 (86#) = happyShift action_26+action_61 (92#) = happyShift action_27+action_61 (94#) = happyShift action_28+action_61 (96#) = happyShift action_29+action_61 (97#) = happyShift action_30+action_61 (98#) = happyShift action_31+action_61 (6#) = happyGoto action_2+action_61 (7#) = happyGoto action_141+action_61 (9#) = happyGoto action_4+action_61 (16#) = happyGoto action_5+action_61 (17#) = happyGoto action_6+action_61 (18#) = happyGoto action_7+action_61 (21#) = happyGoto action_8+action_61 (24#) = happyGoto action_9+action_61 (25#) = happyGoto action_10+action_61 (26#) = happyGoto action_11+action_61 x = happyTcHack x happyFail++action_62 (28#) = happyShift action_12+action_62 (29#) = happyShift action_13+action_62 (30#) = happyShift action_14+action_62 (35#) = happyShift action_15+action_62 (42#) = happyShift action_16+action_62 (43#) = happyShift action_17+action_62 (44#) = happyShift action_18+action_62 (50#) = happyShift action_19+action_62 (65#) = happyShift action_20+action_62 (69#) = happyShift action_21+action_62 (70#) = happyShift action_22+action_62 (79#) = happyShift action_23+action_62 (80#) = happyShift action_24+action_62 (84#) = happyShift action_25+action_62 (86#) = happyShift action_26+action_62 (92#) = happyShift action_27+action_62 (94#) = happyShift action_28+action_62 (96#) = happyShift action_29+action_62 (97#) = happyShift action_30+action_62 (98#) = happyShift action_31+action_62 (6#) = happyGoto action_2+action_62 (7#) = happyGoto action_140+action_62 (9#) = happyGoto action_4+action_62 (16#) = happyGoto action_5+action_62 (17#) = happyGoto action_6+action_62 (18#) = happyGoto action_7+action_62 (21#) = happyGoto action_8+action_62 (24#) = happyGoto action_9+action_62 (25#) = happyGoto action_10+action_62 (26#) = happyGoto action_11+action_62 x = happyTcHack x happyFail++action_63 (28#) = happyShift action_12+action_63 (29#) = happyShift action_13+action_63 (30#) = happyShift action_14+action_63 (35#) = happyShift action_15+action_63 (42#) = happyShift action_16+action_63 (43#) = happyShift action_17+action_63 (44#) = happyShift action_18+action_63 (50#) = happyShift action_19+action_63 (65#) = happyShift action_20+action_63 (69#) = happyShift action_21+action_63 (70#) = happyShift action_22+action_63 (79#) = happyShift action_23+action_63 (80#) = happyShift action_24+action_63 (84#) = happyShift action_25+action_63 (86#) = happyShift action_26+action_63 (92#) = happyShift action_27+action_63 (94#) = happyShift action_28+action_63 (96#) = happyShift action_29+action_63 (97#) = happyShift action_30+action_63 (98#) = happyShift action_31+action_63 (6#) = happyGoto action_2+action_63 (7#) = happyGoto action_139+action_63 (9#) = happyGoto action_4+action_63 (16#) = happyGoto action_5+action_63 (17#) = happyGoto action_6+action_63 (18#) = happyGoto action_7+action_63 (21#) = happyGoto action_8+action_63 (24#) = happyGoto action_9+action_63 (25#) = happyGoto action_10+action_63 (26#) = happyGoto action_11+action_63 x = happyTcHack x happyFail++action_64 (28#) = happyShift action_12+action_64 (29#) = happyShift action_13+action_64 (30#) = happyShift action_14+action_64 (35#) = happyShift action_15+action_64 (42#) = happyShift action_16+action_64 (43#) = happyShift action_17+action_64 (44#) = happyShift action_18+action_64 (50#) = happyShift action_19+action_64 (65#) = happyShift action_20+action_64 (69#) = happyShift action_21+action_64 (70#) = happyShift action_22+action_64 (79#) = happyShift action_23+action_64 (80#) = happyShift action_24+action_64 (84#) = happyShift action_25+action_64 (86#) = happyShift action_26+action_64 (92#) = happyShift action_27+action_64 (94#) = happyShift action_28+action_64 (96#) = happyShift action_29+action_64 (97#) = happyShift action_30+action_64 (98#) = happyShift action_31+action_64 (6#) = happyGoto action_2+action_64 (7#) = happyGoto action_138+action_64 (9#) = happyGoto action_4+action_64 (16#) = happyGoto action_5+action_64 (17#) = happyGoto action_6+action_64 (18#) = happyGoto action_7+action_64 (21#) = happyGoto action_8+action_64 (24#) = happyGoto action_9+action_64 (25#) = happyGoto action_10+action_64 (26#) = happyGoto action_11+action_64 x = happyTcHack x happyFail++action_65 x = happyTcHack x happyReduce_2++action_66 (28#) = happyShift action_12+action_66 (29#) = happyShift action_13+action_66 (30#) = happyShift action_14+action_66 (35#) = happyShift action_15+action_66 (36#) = happyShift action_137+action_66 (42#) = happyShift action_16+action_66 (43#) = happyShift action_17+action_66 (44#) = happyShift action_18+action_66 (50#) = happyShift action_19+action_66 (65#) = happyShift action_20+action_66 (69#) = happyShift action_21+action_66 (70#) = happyShift action_22+action_66 (79#) = happyShift action_23+action_66 (80#) = happyShift action_24+action_66 (84#) = happyShift action_25+action_66 (86#) = happyShift action_26+action_66 (92#) = happyShift action_27+action_66 (94#) = happyShift action_28+action_66 (96#) = happyShift action_29+action_66 (97#) = happyShift action_30+action_66 (98#) = happyShift action_31+action_66 (6#) = happyGoto action_2+action_66 (7#) = happyGoto action_82+action_66 (8#) = happyGoto action_136+action_66 (9#) = happyGoto action_4+action_66 (16#) = happyGoto action_5+action_66 (17#) = happyGoto action_6+action_66 (18#) = happyGoto action_7+action_66 (21#) = happyGoto action_8+action_66 (24#) = happyGoto action_9+action_66 (25#) = happyGoto action_10+action_66 (26#) = happyGoto action_11+action_66 x = happyTcHack x happyFail++action_67 (33#) = happyShift action_90+action_67 (85#) = happyShift action_91+action_67 (22#) = happyGoto action_135+action_67 (23#) = happyGoto action_89+action_67 x = happyTcHack x happyReduce_95++action_68 (86#) = happyShift action_134+action_68 x = happyTcHack x happyFail++action_69 (28#) = happyShift action_12+action_69 (29#) = happyShift action_13+action_69 (30#) = happyShift action_14+action_69 (35#) = happyShift action_15+action_69 (42#) = happyShift action_16+action_69 (43#) = happyShift action_17+action_69 (44#) = happyShift action_18+action_69 (50#) = happyShift action_19+action_69 (65#) = happyShift action_20+action_69 (69#) = happyShift action_21+action_69 (70#) = happyShift action_22+action_69 (79#) = happyShift action_23+action_69 (80#) = happyShift action_24+action_69 (84#) = happyShift action_25+action_69 (86#) = happyShift action_26+action_69 (92#) = happyShift action_27+action_69 (94#) = happyShift action_28+action_69 (96#) = happyShift action_29+action_69 (97#) = happyShift action_30+action_69 (98#) = happyShift action_31+action_69 (6#) = happyGoto action_2+action_69 (7#) = happyGoto action_133+action_69 (9#) = happyGoto action_4+action_69 (16#) = happyGoto action_5+action_69 (17#) = happyGoto action_6+action_69 (18#) = happyGoto action_7+action_69 (21#) = happyGoto action_8+action_69 (24#) = happyGoto action_9+action_69 (25#) = happyGoto action_10+action_69 (26#) = happyGoto action_11+action_69 x = happyTcHack x happyFail++action_70 (37#) = happyShift action_132+action_70 x = happyTcHack x happyFail++action_71 (86#) = happyShift action_131+action_71 x = happyTcHack x happyFail++action_72 (28#) = happyShift action_12+action_72 (29#) = happyShift action_13+action_72 (30#) = happyShift action_14+action_72 (35#) = happyShift action_15+action_72 (42#) = happyShift action_16+action_72 (43#) = happyShift action_17+action_72 (44#) = happyShift action_18+action_72 (50#) = happyShift action_19+action_72 (65#) = happyShift action_20+action_72 (69#) = happyShift action_21+action_72 (70#) = happyShift action_22+action_72 (79#) = happyShift action_23+action_72 (80#) = happyShift action_24+action_72 (84#) = happyShift action_25+action_72 (86#) = happyShift action_26+action_72 (92#) = happyShift action_27+action_72 (94#) = happyShift action_28+action_72 (96#) = happyShift action_29+action_72 (97#) = happyShift action_30+action_72 (98#) = happyShift action_31+action_72 (6#) = happyGoto action_2+action_72 (7#) = happyGoto action_130+action_72 (9#) = happyGoto action_4+action_72 (16#) = happyGoto action_5+action_72 (17#) = happyGoto action_6+action_72 (18#) = happyGoto action_7+action_72 (21#) = happyGoto action_8+action_72 (24#) = happyGoto action_9+action_72 (25#) = happyGoto action_10+action_72 (26#) = happyGoto action_11+action_72 x = happyTcHack x happyFail++action_73 (37#) = happyShift action_129+action_73 x = happyTcHack x happyFail++action_74 (73#) = happyShift action_128+action_74 x = happyTcHack x happyFail++action_75 (72#) = happyShift action_127+action_75 x = happyTcHack x happyReduce_53++action_76 (71#) = happyShift action_125+action_76 (90#) = happyShift action_126+action_76 x = happyTcHack x happyFail++action_77 (72#) = happyShift action_117+action_77 x = happyTcHack x happyReduce_52++action_78 x = happyTcHack x happyReduce_46++action_79 (86#) = happyShift action_124+action_79 (20#) = happyGoto action_123+action_79 x = happyTcHack x happyReduce_80++action_80 x = happyTcHack x happyReduce_45++action_81 x = happyTcHack x happyReduce_44++action_82 (41#) = happyShift action_37+action_82 (42#) = happyShift action_38+action_82 (43#) = happyShift action_39+action_82 (44#) = happyShift action_40+action_82 (45#) = happyShift action_41+action_82 (46#) = happyShift action_42+action_82 (47#) = happyShift action_43+action_82 (48#) = happyShift action_44+action_82 (49#) = happyShift action_45+action_82 (50#) = happyShift action_46+action_82 (51#) = happyShift action_47+action_82 (52#) = happyShift action_48+action_82 (53#) = happyShift action_49+action_82 (54#) = happyShift action_50+action_82 (55#) = happyShift action_51+action_82 (56#) = happyShift action_52+action_82 (57#) = happyShift action_53+action_82 (58#) = happyShift action_54+action_82 (59#) = happyShift action_55+action_82 (60#) = happyShift action_56+action_82 (61#) = happyShift action_57+action_82 (62#) = happyShift action_58+action_82 (63#) = happyShift action_59+action_82 (64#) = happyShift action_60+action_82 (65#) = happyShift action_61+action_82 (66#) = happyShift action_62+action_82 (67#) = happyShift action_63+action_82 (68#) = happyShift action_64+action_82 x = happyTcHack x happyReduce_50++action_83 (36#) = happyShift action_121+action_83 (72#) = happyShift action_122+action_83 x = happyTcHack x happyFail++action_84 x = happyTcHack x happyReduce_113++action_85 (31#) = happyShift action_120+action_85 (41#) = happyShift action_37+action_85 (42#) = happyShift action_38+action_85 (43#) = happyShift action_39+action_85 (44#) = happyShift action_40+action_85 (45#) = happyShift action_41+action_85 (46#) = happyShift action_42+action_85 (47#) = happyShift action_43+action_85 (48#) = happyShift action_44+action_85 (49#) = happyShift action_45+action_85 (50#) = happyShift action_46+action_85 (51#) = happyShift action_47+action_85 (52#) = happyShift action_48+action_85 (53#) = happyShift action_49+action_85 (54#) = happyShift action_50+action_85 (55#) = happyShift action_51+action_85 (56#) = happyShift action_52+action_85 (57#) = happyShift action_53+action_85 (58#) = happyShift action_54+action_85 (59#) = happyShift action_55+action_85 (60#) = happyShift action_56+action_85 (61#) = happyShift action_57+action_85 (62#) = happyShift action_58+action_85 (63#) = happyShift action_59+action_85 (64#) = happyShift action_60+action_85 (65#) = happyShift action_61+action_85 (66#) = happyShift action_62+action_85 (67#) = happyShift action_63+action_85 (68#) = happyShift action_64+action_85 x = happyTcHack x happyFail++action_86 (72#) = happyShift action_117+action_86 (83#) = happyShift action_119+action_86 x = happyTcHack x happyFail++action_87 (72#) = happyShift action_117+action_87 (83#) = happyShift action_118+action_87 x = happyTcHack x happyFail++action_88 (85#) = happyShift action_91+action_88 (23#) = happyGoto action_116+action_88 x = happyTcHack x happyReduce_96++action_89 x = happyTcHack x happyReduce_98++action_90 (28#) = happyShift action_12+action_90 (29#) = happyShift action_13+action_90 (30#) = happyShift action_14+action_90 (35#) = happyShift action_15+action_90 (42#) = happyShift action_16+action_90 (43#) = happyShift action_17+action_90 (44#) = happyShift action_18+action_90 (50#) = happyShift action_19+action_90 (65#) = happyShift action_20+action_90 (69#) = happyShift action_21+action_90 (70#) = happyShift action_22+action_90 (79#) = happyShift action_23+action_90 (80#) = happyShift action_24+action_90 (84#) = happyShift action_25+action_90 (86#) = happyShift action_26+action_90 (92#) = happyShift action_27+action_90 (94#) = happyShift action_28+action_90 (96#) = happyShift action_29+action_90 (97#) = happyShift action_30+action_90 (98#) = happyShift action_31+action_90 (6#) = happyGoto action_2+action_90 (7#) = happyGoto action_115+action_90 (9#) = happyGoto action_4+action_90 (16#) = happyGoto action_5+action_90 (17#) = happyGoto action_6+action_90 (18#) = happyGoto action_7+action_90 (21#) = happyGoto action_8+action_90 (24#) = happyGoto action_9+action_90 (25#) = happyGoto action_10+action_90 (26#) = happyGoto action_11+action_90 x = happyTcHack x happyFail++action_91 (35#) = happyShift action_15+action_91 (44#) = happyShift action_18+action_91 (84#) = happyShift action_112+action_91 (85#) = happyShift action_113+action_91 (86#) = happyShift action_26+action_91 (91#) = happyShift action_114+action_91 (92#) = happyShift action_27+action_91 (94#) = happyShift action_28+action_91 (6#) = happyGoto action_2+action_91 (24#) = happyGoto action_111+action_91 (25#) = happyGoto action_10+action_91 (26#) = happyGoto action_11+action_91 x = happyTcHack x happyFail++action_92 (37#) = happyShift action_105+action_92 (50#) = happyShift action_19+action_92 (79#) = happyShift action_106+action_92 (80#) = happyShift action_107+action_92 (81#) = happyShift action_108+action_92 (95#) = happyShift action_109+action_92 (98#) = happyShift action_110+action_92 (17#) = happyGoto action_103+action_92 (18#) = happyGoto action_7+action_92 (19#) = happyGoto action_104+action_92 x = happyTcHack x happyFail++action_93 x = happyTcHack x happyReduce_75++action_94 (75#) = happyShift action_102+action_94 (13#) = happyGoto action_101+action_94 x = happyTcHack x happyReduce_65++action_95 (94#) = happyShift action_28+action_95 (6#) = happyGoto action_76+action_95 (10#) = happyGoto action_100+action_95 x = happyTcHack x happyFail++action_96 (94#) = happyShift action_28+action_96 (6#) = happyGoto action_74+action_96 (11#) = happyGoto action_99+action_96 x = happyTcHack x happyFail++action_97 (28#) = happyShift action_12+action_97 (29#) = happyShift action_13+action_97 (30#) = happyShift action_14+action_97 (35#) = happyShift action_15+action_97 (42#) = happyShift action_16+action_97 (43#) = happyShift action_17+action_97 (44#) = happyShift action_18+action_97 (50#) = happyShift action_19+action_97 (65#) = happyShift action_20+action_97 (69#) = happyShift action_21+action_97 (70#) = happyShift action_22+action_97 (79#) = happyShift action_23+action_97 (80#) = happyShift action_24+action_97 (84#) = happyShift action_25+action_97 (86#) = happyShift action_26+action_97 (92#) = happyShift action_27+action_97 (94#) = happyShift action_28+action_97 (96#) = happyShift action_29+action_97 (97#) = happyShift action_30+action_97 (98#) = happyShift action_31+action_97 (6#) = happyGoto action_2+action_97 (7#) = happyGoto action_98+action_97 (9#) = happyGoto action_4+action_97 (16#) = happyGoto action_5+action_97 (17#) = happyGoto action_6+action_97 (18#) = happyGoto action_7+action_97 (21#) = happyGoto action_8+action_97 (24#) = happyGoto action_9+action_97 (25#) = happyGoto action_10+action_97 (26#) = happyGoto action_11+action_97 x = happyTcHack x happyFail++action_98 (41#) = happyShift action_37+action_98 (42#) = happyShift action_38+action_98 (43#) = happyShift action_39+action_98 (44#) = happyShift action_40+action_98 (45#) = happyShift action_41+action_98 (46#) = happyShift action_42+action_98 (47#) = happyShift action_43+action_98 (48#) = happyShift action_44+action_98 (49#) = happyShift action_45+action_98 (50#) = happyShift action_46+action_98 (51#) = happyShift action_47+action_98 (52#) = happyShift action_48+action_98 (53#) = happyShift action_49+action_98 (54#) = happyShift action_50+action_98 (55#) = happyShift action_51+action_98 (56#) = happyShift action_52+action_98 (57#) = happyShift action_53+action_98 (58#) = happyShift action_54+action_98 (59#) = happyShift action_55+action_98 (60#) = happyShift action_56+action_98 (61#) = happyShift action_57+action_98 (62#) = happyShift action_58+action_98 (63#) = happyShift action_59+action_98 (64#) = happyShift action_60+action_98 (65#) = happyShift action_61+action_98 (66#) = happyShift action_62+action_98 (67#) = happyShift action_63+action_98 (68#) = happyShift action_64+action_98 x = happyTcHack x happyReduce_62++action_99 (72#) = happyShift action_127+action_99 x = happyTcHack x happyReduce_55++action_100 (72#) = happyShift action_117+action_100 x = happyTcHack x happyReduce_54++action_101 (27#) = happyShift action_200+action_101 x = happyTcHack x happyFail++action_102 (76#) = happyShift action_199+action_102 x = happyTcHack x happyFail++action_103 x = happyTcHack x happyReduce_85++action_104 (37#) = happyShift action_195+action_104 (50#) = happyShift action_19+action_104 (79#) = happyShift action_106+action_104 (80#) = happyShift action_107+action_104 (81#) = happyShift action_196+action_104 (95#) = happyShift action_197+action_104 (98#) = happyShift action_198+action_104 (17#) = happyGoto action_194+action_104 (18#) = happyGoto action_7+action_104 x = happyTcHack x happyFail++action_105 (28#) = happyShift action_12+action_105 (29#) = happyShift action_13+action_105 (30#) = happyShift action_14+action_105 (35#) = happyShift action_15+action_105 (42#) = happyShift action_16+action_105 (43#) = happyShift action_17+action_105 (44#) = happyShift action_18+action_105 (50#) = happyShift action_19+action_105 (65#) = happyShift action_20+action_105 (69#) = happyShift action_21+action_105 (70#) = happyShift action_22+action_105 (79#) = happyShift action_23+action_105 (80#) = happyShift action_24+action_105 (84#) = happyShift action_25+action_105 (86#) = happyShift action_26+action_105 (92#) = happyShift action_27+action_105 (94#) = happyShift action_28+action_105 (96#) = happyShift action_29+action_105 (97#) = happyShift action_30+action_105 (98#) = happyShift action_31+action_105 (6#) = happyGoto action_2+action_105 (7#) = happyGoto action_82+action_105 (8#) = happyGoto action_193+action_105 (9#) = happyGoto action_4+action_105 (16#) = happyGoto action_5+action_105 (17#) = happyGoto action_6+action_105 (18#) = happyGoto action_7+action_105 (21#) = happyGoto action_8+action_105 (24#) = happyGoto action_9+action_105 (25#) = happyGoto action_10+action_105 (26#) = happyGoto action_11+action_105 x = happyTcHack x happyFail++action_106 (37#) = happyShift action_72+action_106 (86#) = happyShift action_73+action_106 x = happyTcHack x happyFail++action_107 (37#) = happyShift action_69+action_107 (86#) = happyShift action_70+action_107 x = happyTcHack x happyFail++action_108 (86#) = happyShift action_192+action_108 x = happyTcHack x happyFail++action_109 x = happyTcHack x happyReduce_84++action_110 x = happyTcHack x happyReduce_83++action_111 (33#) = happyShift action_90+action_111 x = happyTcHack x happyReduce_100++action_112 (35#) = happyShift action_15+action_112 (44#) = happyShift action_18+action_112 (86#) = happyShift action_26+action_112 (92#) = happyShift action_27+action_112 (94#) = happyShift action_28+action_112 (6#) = happyGoto action_2+action_112 (24#) = happyGoto action_191+action_112 (25#) = happyGoto action_10+action_112 (26#) = happyGoto action_11+action_112 x = happyTcHack x happyFail++action_113 (35#) = happyShift action_15+action_113 (44#) = happyShift action_18+action_113 (84#) = happyShift action_190+action_113 (86#) = happyShift action_26+action_113 (92#) = happyShift action_27+action_113 (94#) = happyShift action_28+action_113 (6#) = happyGoto action_2+action_113 (24#) = happyGoto action_189+action_113 (25#) = happyGoto action_10+action_113 (26#) = happyGoto action_11+action_113 x = happyTcHack x happyFail++action_114 x = happyTcHack x happyReduce_104++action_115 (34#) = happyShift action_188+action_115 (41#) = happyShift action_37+action_115 (42#) = happyShift action_38+action_115 (43#) = happyShift action_39+action_115 (44#) = happyShift action_40+action_115 (45#) = happyShift action_41+action_115 (46#) = happyShift action_42+action_115 (47#) = happyShift action_43+action_115 (48#) = happyShift action_44+action_115 (49#) = happyShift action_45+action_115 (50#) = happyShift action_46+action_115 (51#) = happyShift action_47+action_115 (52#) = happyShift action_48+action_115 (53#) = happyShift action_49+action_115 (54#) = happyShift action_50+action_115 (55#) = happyShift action_51+action_115 (56#) = happyShift action_52+action_115 (57#) = happyShift action_53+action_115 (58#) = happyShift action_54+action_115 (59#) = happyShift action_55+action_115 (60#) = happyShift action_56+action_115 (61#) = happyShift action_57+action_115 (62#) = happyShift action_58+action_115 (63#) = happyShift action_59+action_115 (64#) = happyShift action_60+action_115 (65#) = happyShift action_61+action_115 (66#) = happyShift action_62+action_115 (67#) = happyShift action_63+action_115 (68#) = happyShift action_64+action_115 x = happyTcHack x happyFail++action_116 x = happyTcHack x happyReduce_99++action_117 (94#) = happyShift action_28+action_117 (6#) = happyGoto action_187+action_117 x = happyTcHack x happyFail++action_118 (28#) = happyShift action_12+action_118 (29#) = happyShift action_13+action_118 (30#) = happyShift action_14+action_118 (35#) = happyShift action_15+action_118 (42#) = happyShift action_16+action_118 (43#) = happyShift action_17+action_118 (44#) = happyShift action_18+action_118 (50#) = happyShift action_19+action_118 (65#) = happyShift action_20+action_118 (69#) = happyShift action_21+action_118 (70#) = happyShift action_22+action_118 (79#) = happyShift action_23+action_118 (80#) = happyShift action_24+action_118 (84#) = happyShift action_25+action_118 (86#) = happyShift action_26+action_118 (92#) = happyShift action_27+action_118 (94#) = happyShift action_28+action_118 (96#) = happyShift action_29+action_118 (97#) = happyShift action_30+action_118 (98#) = happyShift action_31+action_118 (6#) = happyGoto action_2+action_118 (7#) = happyGoto action_186+action_118 (9#) = happyGoto action_4+action_118 (16#) = happyGoto action_5+action_118 (17#) = happyGoto action_6+action_118 (18#) = happyGoto action_7+action_118 (21#) = happyGoto action_8+action_118 (24#) = happyGoto action_9+action_118 (25#) = happyGoto action_10+action_118 (26#) = happyGoto action_11+action_118 x = happyTcHack x happyFail++action_119 (28#) = happyShift action_12+action_119 (29#) = happyShift action_13+action_119 (30#) = happyShift action_14+action_119 (35#) = happyShift action_15+action_119 (42#) = happyShift action_16+action_119 (43#) = happyShift action_17+action_119 (44#) = happyShift action_18+action_119 (50#) = happyShift action_19+action_119 (65#) = happyShift action_20+action_119 (69#) = happyShift action_21+action_119 (70#) = happyShift action_22+action_119 (79#) = happyShift action_23+action_119 (80#) = happyShift action_24+action_119 (84#) = happyShift action_25+action_119 (86#) = happyShift action_26+action_119 (92#) = happyShift action_27+action_119 (94#) = happyShift action_28+action_119 (96#) = happyShift action_29+action_119 (97#) = happyShift action_30+action_119 (98#) = happyShift action_31+action_119 (6#) = happyGoto action_2+action_119 (7#) = happyGoto action_185+action_119 (9#) = happyGoto action_4+action_119 (16#) = happyGoto action_5+action_119 (17#) = happyGoto action_6+action_119 (18#) = happyGoto action_7+action_119 (21#) = happyGoto action_8+action_119 (24#) = happyGoto action_9+action_119 (25#) = happyGoto action_10+action_119 (26#) = happyGoto action_11+action_119 x = happyTcHack x happyFail++action_120 (28#) = happyShift action_12+action_120 (29#) = happyShift action_13+action_120 (30#) = happyShift action_14+action_120 (35#) = happyShift action_15+action_120 (42#) = happyShift action_16+action_120 (43#) = happyShift action_17+action_120 (44#) = happyShift action_18+action_120 (50#) = happyShift action_19+action_120 (65#) = happyShift action_20+action_120 (69#) = happyShift action_21+action_120 (70#) = happyShift action_22+action_120 (79#) = happyShift action_23+action_120 (80#) = happyShift action_24+action_120 (84#) = happyShift action_25+action_120 (86#) = happyShift action_26+action_120 (92#) = happyShift action_27+action_120 (94#) = happyShift action_28+action_120 (96#) = happyShift action_29+action_120 (97#) = happyShift action_30+action_120 (98#) = happyShift action_31+action_120 (6#) = happyGoto action_2+action_120 (7#) = happyGoto action_184+action_120 (9#) = happyGoto action_4+action_120 (16#) = happyGoto action_5+action_120 (17#) = happyGoto action_6+action_120 (18#) = happyGoto action_7+action_120 (21#) = happyGoto action_8+action_120 (24#) = happyGoto action_9+action_120 (25#) = happyGoto action_10+action_120 (26#) = happyGoto action_11+action_120 x = happyTcHack x happyFail++action_121 x = happyTcHack x happyReduce_112++action_122 (28#) = happyShift action_12+action_122 (29#) = happyShift action_13+action_122 (30#) = happyShift action_14+action_122 (35#) = happyShift action_15+action_122 (42#) = happyShift action_16+action_122 (43#) = happyShift action_17+action_122 (44#) = happyShift action_18+action_122 (50#) = happyShift action_19+action_122 (65#) = happyShift action_20+action_122 (69#) = happyShift action_21+action_122 (70#) = happyShift action_22+action_122 (79#) = happyShift action_23+action_122 (80#) = happyShift action_24+action_122 (84#) = happyShift action_25+action_122 (86#) = happyShift action_26+action_122 (92#) = happyShift action_27+action_122 (94#) = happyShift action_28+action_122 (96#) = happyShift action_29+action_122 (97#) = happyShift action_30+action_122 (98#) = happyShift action_31+action_122 (6#) = happyGoto action_2+action_122 (7#) = happyGoto action_183+action_122 (9#) = happyGoto action_4+action_122 (16#) = happyGoto action_5+action_122 (17#) = happyGoto action_6+action_122 (18#) = happyGoto action_7+action_122 (21#) = happyGoto action_8+action_122 (24#) = happyGoto action_9+action_122 (25#) = happyGoto action_10+action_122 (26#) = happyGoto action_11+action_122 x = happyTcHack x happyFail++action_123 (86#) = happyShift action_182+action_123 x = happyTcHack x happyReduce_81++action_124 (48#) = happyShift action_181+action_124 x = happyTcHack x happyFail++action_125 (28#) = happyShift action_12+action_125 (29#) = happyShift action_13+action_125 (30#) = happyShift action_14+action_125 (35#) = happyShift action_15+action_125 (42#) = happyShift action_16+action_125 (43#) = happyShift action_17+action_125 (44#) = happyShift action_18+action_125 (50#) = happyShift action_19+action_125 (65#) = happyShift action_20+action_125 (69#) = happyShift action_21+action_125 (70#) = happyShift action_22+action_125 (79#) = happyShift action_23+action_125 (80#) = happyShift action_24+action_125 (84#) = happyShift action_25+action_125 (86#) = happyShift action_26+action_125 (92#) = happyShift action_27+action_125 (94#) = happyShift action_28+action_125 (96#) = happyShift action_29+action_125 (97#) = happyShift action_30+action_125 (98#) = happyShift action_31+action_125 (6#) = happyGoto action_2+action_125 (7#) = happyGoto action_180+action_125 (9#) = happyGoto action_4+action_125 (16#) = happyGoto action_5+action_125 (17#) = happyGoto action_6+action_125 (18#) = happyGoto action_7+action_125 (21#) = happyGoto action_8+action_125 (24#) = happyGoto action_9+action_125 (25#) = happyGoto action_10+action_125 (26#) = happyGoto action_11+action_125 x = happyTcHack x happyFail++action_126 (94#) = happyShift action_28+action_126 (6#) = happyGoto action_179+action_126 x = happyTcHack x happyFail++action_127 (94#) = happyShift action_28+action_127 (6#) = happyGoto action_178+action_127 x = happyTcHack x happyFail++action_128 (28#) = happyShift action_12+action_128 (29#) = happyShift action_13+action_128 (30#) = happyShift action_14+action_128 (35#) = happyShift action_15+action_128 (42#) = happyShift action_16+action_128 (43#) = happyShift action_17+action_128 (44#) = happyShift action_18+action_128 (50#) = happyShift action_19+action_128 (65#) = happyShift action_20+action_128 (69#) = happyShift action_21+action_128 (70#) = happyShift action_22+action_128 (79#) = happyShift action_23+action_128 (80#) = happyShift action_24+action_128 (84#) = happyShift action_25+action_128 (86#) = happyShift action_26+action_128 (92#) = happyShift action_27+action_128 (94#) = happyShift action_28+action_128 (96#) = happyShift action_29+action_128 (97#) = happyShift action_30+action_128 (98#) = happyShift action_31+action_128 (6#) = happyGoto action_2+action_128 (7#) = happyGoto action_177+action_128 (9#) = happyGoto action_4+action_128 (16#) = happyGoto action_5+action_128 (17#) = happyGoto action_6+action_128 (18#) = happyGoto action_7+action_128 (21#) = happyGoto action_8+action_128 (24#) = happyGoto action_9+action_128 (25#) = happyGoto action_10+action_128 (26#) = happyGoto action_11+action_128 x = happyTcHack x happyFail++action_129 (28#) = happyShift action_12+action_129 (29#) = happyShift action_13+action_129 (30#) = happyShift action_14+action_129 (35#) = happyShift action_15+action_129 (42#) = happyShift action_16+action_129 (43#) = happyShift action_17+action_129 (44#) = happyShift action_18+action_129 (50#) = happyShift action_19+action_129 (65#) = happyShift action_20+action_129 (69#) = happyShift action_21+action_129 (70#) = happyShift action_22+action_129 (79#) = happyShift action_23+action_129 (80#) = happyShift action_24+action_129 (84#) = happyShift action_25+action_129 (86#) = happyShift action_26+action_129 (92#) = happyShift action_27+action_129 (94#) = happyShift action_28+action_129 (96#) = happyShift action_29+action_129 (97#) = happyShift action_30+action_129 (98#) = happyShift action_31+action_129 (6#) = happyGoto action_2+action_129 (7#) = happyGoto action_82+action_129 (8#) = happyGoto action_176+action_129 (9#) = happyGoto action_4+action_129 (16#) = happyGoto action_5+action_129 (17#) = happyGoto action_6+action_129 (18#) = happyGoto action_7+action_129 (21#) = happyGoto action_8+action_129 (24#) = happyGoto action_9+action_129 (25#) = happyGoto action_10+action_129 (26#) = happyGoto action_11+action_129 x = happyTcHack x happyFail++action_130 (38#) = happyShift action_175+action_130 (41#) = happyShift action_37+action_130 (42#) = happyShift action_38+action_130 (43#) = happyShift action_39+action_130 (44#) = happyShift action_40+action_130 (45#) = happyShift action_41+action_130 (46#) = happyShift action_42+action_130 (47#) = happyShift action_43+action_130 (48#) = happyShift action_44+action_130 (49#) = happyShift action_45+action_130 (50#) = happyShift action_46+action_130 (51#) = happyShift action_47+action_130 (52#) = happyShift action_48+action_130 (53#) = happyShift action_49+action_130 (54#) = happyShift action_50+action_130 (55#) = happyShift action_51+action_130 (56#) = happyShift action_52+action_130 (57#) = happyShift action_53+action_130 (58#) = happyShift action_54+action_130 (59#) = happyShift action_55+action_130 (60#) = happyShift action_56+action_130 (61#) = happyShift action_57+action_130 (62#) = happyShift action_58+action_130 (63#) = happyShift action_59+action_130 (64#) = happyShift action_60+action_130 (65#) = happyShift action_61+action_130 (66#) = happyShift action_62+action_130 (67#) = happyShift action_63+action_130 (68#) = happyShift action_64+action_130 x = happyTcHack x happyFail++action_131 (36#) = happyShift action_174+action_131 x = happyTcHack x happyFail++action_132 (28#) = happyShift action_12+action_132 (29#) = happyShift action_13+action_132 (30#) = happyShift action_14+action_132 (35#) = happyShift action_15+action_132 (42#) = happyShift action_16+action_132 (43#) = happyShift action_17+action_132 (44#) = happyShift action_18+action_132 (50#) = happyShift action_19+action_132 (65#) = happyShift action_20+action_132 (69#) = happyShift action_21+action_132 (70#) = happyShift action_22+action_132 (79#) = happyShift action_23+action_132 (80#) = happyShift action_24+action_132 (84#) = happyShift action_25+action_132 (86#) = happyShift action_26+action_132 (92#) = happyShift action_27+action_132 (94#) = happyShift action_28+action_132 (96#) = happyShift action_29+action_132 (97#) = happyShift action_30+action_132 (98#) = happyShift action_31+action_132 (6#) = happyGoto action_2+action_132 (7#) = happyGoto action_82+action_132 (8#) = happyGoto action_173+action_132 (9#) = happyGoto action_4+action_132 (16#) = happyGoto action_5+action_132 (17#) = happyGoto action_6+action_132 (18#) = happyGoto action_7+action_132 (21#) = happyGoto action_8+action_132 (24#) = happyGoto action_9+action_132 (25#) = happyGoto action_10+action_132 (26#) = happyGoto action_11+action_132 x = happyTcHack x happyFail++action_133 (38#) = happyShift action_172+action_133 (41#) = happyShift action_37+action_133 (42#) = happyShift action_38+action_133 (43#) = happyShift action_39+action_133 (44#) = happyShift action_40+action_133 (45#) = happyShift action_41+action_133 (46#) = happyShift action_42+action_133 (47#) = happyShift action_43+action_133 (48#) = happyShift action_44+action_133 (49#) = happyShift action_45+action_133 (50#) = happyShift action_46+action_133 (51#) = happyShift action_47+action_133 (52#) = happyShift action_48+action_133 (53#) = happyShift action_49+action_133 (54#) = happyShift action_50+action_133 (55#) = happyShift action_51+action_133 (56#) = happyShift action_52+action_133 (57#) = happyShift action_53+action_133 (58#) = happyShift action_54+action_133 (59#) = happyShift action_55+action_133 (60#) = happyShift action_56+action_133 (61#) = happyShift action_57+action_133 (62#) = happyShift action_58+action_133 (63#) = happyShift action_59+action_133 (64#) = happyShift action_60+action_133 (65#) = happyShift action_61+action_133 (66#) = happyShift action_62+action_133 (67#) = happyShift action_63+action_133 (68#) = happyShift action_64+action_133 x = happyTcHack x happyFail++action_134 (36#) = happyShift action_171+action_134 x = happyTcHack x happyFail++action_135 (85#) = happyShift action_91+action_135 (23#) = happyGoto action_116+action_135 x = happyTcHack x happyReduce_97++action_136 (36#) = happyShift action_170+action_136 (72#) = happyShift action_122+action_136 x = happyTcHack x happyFail++action_137 x = happyTcHack x happyReduce_115++action_138 (41#) = happyShift action_37+action_138 (42#) = happyShift action_38+action_138 (43#) = happyShift action_39+action_138 (44#) = happyShift action_40+action_138 (45#) = happyShift action_41+action_138 (46#) = happyShift action_42+action_138 (47#) = happyShift action_43+action_138 (48#) = happyShift action_44+action_138 (49#) = happyShift action_45+action_138 (50#) = happyShift action_46+action_138 (51#) = happyShift action_47+action_138 (52#) = happyShift action_48+action_138 (53#) = happyShift action_49+action_138 (54#) = happyShift action_50+action_138 (55#) = happyShift action_51+action_138 (56#) = happyShift action_52+action_138 (57#) = happyShift action_53+action_138 (58#) = happyShift action_54+action_138 (59#) = happyShift action_55+action_138 (60#) = happyShift action_56+action_138 (61#) = happyShift action_57+action_138 (62#) = happyShift action_58+action_138 (63#) = happyShift action_59+action_138 (64#) = happyShift action_60+action_138 (65#) = happyShift action_61+action_138 x = happyTcHack x happyReduce_43++action_139 (41#) = happyShift action_37+action_139 (42#) = happyShift action_38+action_139 (43#) = happyShift action_39+action_139 (44#) = happyShift action_40+action_139 (45#) = happyShift action_41+action_139 (46#) = happyShift action_42+action_139 (47#) = happyShift action_43+action_139 (48#) = happyShift action_44+action_139 (49#) = happyShift action_45+action_139 (50#) = happyShift action_46+action_139 (51#) = happyShift action_47+action_139 (52#) = happyShift action_48+action_139 (53#) = happyShift action_49+action_139 (54#) = happyShift action_50+action_139 (55#) = happyShift action_51+action_139 (56#) = happyShift action_52+action_139 (57#) = happyShift action_53+action_139 (58#) = happyShift action_54+action_139 (59#) = happyShift action_55+action_139 (60#) = happyShift action_56+action_139 (61#) = happyShift action_57+action_139 (62#) = happyShift action_58+action_139 (63#) = happyShift action_59+action_139 (64#) = happyShift action_60+action_139 (65#) = happyShift action_61+action_139 x = happyTcHack x happyReduce_42++action_140 (41#) = happyShift action_37+action_140 (42#) = happyShift action_38+action_140 (43#) = happyShift action_39+action_140 (44#) = happyShift action_40+action_140 (45#) = happyShift action_41+action_140 (46#) = happyShift action_42+action_140 (47#) = happyShift action_43+action_140 (48#) = happyShift action_44+action_140 (49#) = happyShift action_45+action_140 (50#) = happyShift action_46+action_140 (51#) = happyShift action_47+action_140 (52#) = happyShift action_48+action_140 (53#) = happyShift action_49+action_140 (54#) = happyShift action_50+action_140 (55#) = happyShift action_51+action_140 (56#) = happyShift action_52+action_140 (57#) = happyShift action_53+action_140 (58#) = happyShift action_54+action_140 (59#) = happyShift action_55+action_140 (60#) = happyShift action_56+action_140 (61#) = happyShift action_57+action_140 (62#) = happyShift action_58+action_140 (63#) = happyShift action_59+action_140 (64#) = happyShift action_60+action_140 (65#) = happyShift action_61+action_140 x = happyTcHack x happyReduce_41++action_141 (41#) = happyShift action_37+action_141 (42#) = happyShift action_38+action_141 (43#) = happyShift action_39+action_141 (44#) = happyShift action_40+action_141 (45#) = happyShift action_41+action_141 (46#) = happyShift action_42+action_141 (47#) = happyShift action_43+action_141 (48#) = happyShift action_44+action_141 (49#) = happyShift action_45+action_141 (50#) = happyShift action_46+action_141 (51#) = happyShift action_47+action_141 (52#) = happyShift action_48+action_141 (53#) = happyShift action_49+action_141 (54#) = happyShift action_50+action_141 (55#) = happyShift action_51+action_141 (56#) = happyShift action_52+action_141 (57#) = happyShift action_53+action_141 (58#) = happyShift action_54+action_141 (59#) = happyShift action_55+action_141 (60#) = happyShift action_56+action_141 (61#) = happyShift action_57+action_141 (62#) = happyShift action_58+action_141 (65#) = happyFail+action_141 x = happyTcHack x happyReduce_40++action_142 (41#) = happyShift action_37+action_142 (42#) = happyShift action_38+action_142 (43#) = happyShift action_39+action_142 (44#) = happyShift action_40+action_142 (45#) = happyShift action_41+action_142 (46#) = happyShift action_42+action_142 (47#) = happyShift action_43+action_142 (48#) = happyShift action_44+action_142 (49#) = happyShift action_45+action_142 (50#) = happyShift action_46+action_142 (51#) = happyShift action_47+action_142 (52#) = happyShift action_48+action_142 (53#) = happyShift action_49+action_142 (54#) = happyShift action_50+action_142 (55#) = happyShift action_51+action_142 (56#) = happyShift action_52+action_142 (57#) = happyShift action_53+action_142 (58#) = happyShift action_54+action_142 (59#) = happyShift action_55+action_142 (60#) = happyShift action_56+action_142 (61#) = happyShift action_57+action_142 (62#) = happyShift action_58+action_142 (63#) = happyShift action_59+action_142 (64#) = happyShift action_60+action_142 (65#) = happyShift action_61+action_142 x = happyTcHack x happyReduce_39++action_143 (41#) = happyShift action_37+action_143 (42#) = happyShift action_38+action_143 (43#) = happyShift action_39+action_143 (44#) = happyShift action_40+action_143 (45#) = happyShift action_41+action_143 (46#) = happyShift action_42+action_143 (47#) = happyShift action_43+action_143 (48#) = happyShift action_44+action_143 (49#) = happyShift action_45+action_143 (50#) = happyShift action_46+action_143 (51#) = happyShift action_47+action_143 (52#) = happyShift action_48+action_143 (53#) = happyShift action_49+action_143 (54#) = happyShift action_50+action_143 (55#) = happyShift action_51+action_143 (56#) = happyShift action_52+action_143 (57#) = happyShift action_53+action_143 (58#) = happyShift action_54+action_143 (59#) = happyShift action_55+action_143 (60#) = happyShift action_56+action_143 (61#) = happyShift action_57+action_143 (62#) = happyShift action_58+action_143 (63#) = happyShift action_59+action_143 (65#) = happyShift action_61+action_143 x = happyTcHack x happyReduce_38++action_144 (42#) = happyShift action_38+action_144 (43#) = happyShift action_39+action_144 (44#) = happyShift action_40+action_144 (45#) = happyShift action_41+action_144 (46#) = happyShift action_42+action_144 (47#) = happyShift action_43+action_144 x = happyTcHack x happyReduce_37++action_145 (42#) = happyShift action_38+action_145 (43#) = happyShift action_39+action_145 (44#) = happyShift action_40+action_145 (45#) = happyShift action_41+action_145 (46#) = happyShift action_42+action_145 (47#) = happyShift action_43+action_145 x = happyTcHack x happyReduce_36++action_146 (42#) = happyShift action_38+action_146 (43#) = happyShift action_39+action_146 (44#) = happyShift action_40+action_146 (45#) = happyShift action_41+action_146 (46#) = happyShift action_42+action_146 (47#) = happyShift action_43+action_146 x = happyTcHack x happyReduce_35++action_147 (42#) = happyShift action_38+action_147 (43#) = happyShift action_39+action_147 (44#) = happyShift action_40+action_147 (45#) = happyShift action_41+action_147 (46#) = happyShift action_42+action_147 (47#) = happyShift action_43+action_147 x = happyTcHack x happyReduce_34++action_148 (42#) = happyShift action_38+action_148 (43#) = happyShift action_39+action_148 (44#) = happyShift action_40+action_148 (45#) = happyShift action_41+action_148 (46#) = happyShift action_42+action_148 (47#) = happyShift action_43+action_148 x = happyTcHack x happyReduce_33++action_149 (42#) = happyShift action_38+action_149 (43#) = happyShift action_39+action_149 (44#) = happyShift action_40+action_149 (45#) = happyShift action_41+action_149 (46#) = happyShift action_42+action_149 (47#) = happyShift action_43+action_149 x = happyTcHack x happyReduce_32++action_150 (42#) = happyShift action_38+action_150 (43#) = happyShift action_39+action_150 (44#) = happyShift action_40+action_150 (45#) = happyShift action_41+action_150 (46#) = happyShift action_42+action_150 (47#) = happyShift action_43+action_150 x = happyTcHack x happyReduce_31++action_151 (42#) = happyShift action_38+action_151 (43#) = happyShift action_39+action_151 (44#) = happyShift action_40+action_151 (45#) = happyShift action_41+action_151 (46#) = happyShift action_42+action_151 (47#) = happyShift action_43+action_151 x = happyTcHack x happyReduce_30++action_152 (42#) = happyShift action_38+action_152 (43#) = happyShift action_39+action_152 (44#) = happyShift action_40+action_152 (45#) = happyShift action_41+action_152 (46#) = happyShift action_42+action_152 (47#) = happyShift action_43+action_152 x = happyTcHack x happyReduce_29++action_153 (42#) = happyShift action_38+action_153 (43#) = happyShift action_39+action_153 (44#) = happyShift action_40+action_153 (45#) = happyShift action_41+action_153 (46#) = happyShift action_42+action_153 (47#) = happyShift action_43+action_153 x = happyTcHack x happyReduce_28++action_154 (42#) = happyShift action_38+action_154 (43#) = happyShift action_39+action_154 (44#) = happyShift action_40+action_154 (45#) = happyShift action_41+action_154 (46#) = happyShift action_42+action_154 (47#) = happyShift action_43+action_154 x = happyTcHack x happyReduce_27++action_155 (42#) = happyShift action_38+action_155 (43#) = happyShift action_39+action_155 (44#) = happyShift action_40+action_155 (45#) = happyShift action_41+action_155 (46#) = happyShift action_42+action_155 (47#) = happyShift action_43+action_155 x = happyTcHack x happyReduce_26++action_156 (42#) = happyShift action_38+action_156 (43#) = happyShift action_39+action_156 (44#) = happyShift action_40+action_156 (45#) = happyShift action_41+action_156 (46#) = happyShift action_42+action_156 (47#) = happyShift action_43+action_156 x = happyTcHack x happyReduce_25++action_157 (42#) = happyShift action_38+action_157 (43#) = happyShift action_39+action_157 (44#) = happyShift action_40+action_157 (45#) = happyShift action_41+action_157 (46#) = happyShift action_42+action_157 (47#) = happyShift action_43+action_157 x = happyTcHack x happyReduce_24++action_158 (42#) = happyShift action_38+action_158 (43#) = happyShift action_39+action_158 (44#) = happyShift action_40+action_158 (45#) = happyShift action_41+action_158 (46#) = happyShift action_42+action_158 (47#) = happyShift action_43+action_158 x = happyTcHack x happyReduce_23++action_159 x = happyTcHack x happyReduce_22++action_160 x = happyTcHack x happyReduce_21++action_161 x = happyTcHack x happyReduce_20++action_162 x = happyTcHack x happyReduce_19++action_163 (44#) = happyShift action_40+action_163 (45#) = happyShift action_41+action_163 (46#) = happyShift action_42+action_163 (47#) = happyShift action_43+action_163 x = happyTcHack x happyReduce_18++action_164 (44#) = happyShift action_40+action_164 (45#) = happyShift action_41+action_164 (46#) = happyShift action_42+action_164 (47#) = happyShift action_43+action_164 x = happyTcHack x happyReduce_17++action_165 (42#) = happyShift action_38+action_165 (43#) = happyShift action_39+action_165 (44#) = happyShift action_40+action_165 (45#) = happyShift action_41+action_165 (46#) = happyShift action_42+action_165 (47#) = happyShift action_43+action_165 (48#) = happyShift action_44+action_165 (49#) = happyShift action_45+action_165 (50#) = happyShift action_46+action_165 (51#) = happyShift action_47+action_165 (52#) = happyShift action_48+action_165 (53#) = happyShift action_49+action_165 (54#) = happyShift action_50+action_165 (55#) = happyShift action_51+action_165 (56#) = happyShift action_52+action_165 (57#) = happyShift action_53+action_165 (58#) = happyShift action_54+action_165 (59#) = happyShift action_55+action_165 (60#) = happyShift action_56+action_165 (61#) = happyShift action_57+action_165 (62#) = happyShift action_58+action_165 x = happyTcHack x happyReduce_16++action_166 (73#) = happyShift action_169+action_166 x = happyTcHack x happyFail++action_167 (35#) = happyShift action_168+action_167 x = happyTcHack x happyFail++action_168 (36#) = happyShift action_224+action_168 (94#) = happyShift action_28+action_168 (5#) = happyGoto action_222+action_168 (6#) = happyGoto action_223+action_168 x = happyTcHack x happyFail++action_169 (28#) = happyShift action_12+action_169 (29#) = happyShift action_13+action_169 (30#) = happyShift action_14+action_169 (35#) = happyShift action_15+action_169 (42#) = happyShift action_16+action_169 (43#) = happyShift action_17+action_169 (44#) = happyShift action_18+action_169 (50#) = happyShift action_19+action_169 (65#) = happyShift action_20+action_169 (69#) = happyShift action_21+action_169 (70#) = happyShift action_22+action_169 (79#) = happyShift action_23+action_169 (80#) = happyShift action_24+action_169 (84#) = happyShift action_25+action_169 (86#) = happyShift action_26+action_169 (92#) = happyShift action_27+action_169 (94#) = happyShift action_28+action_169 (96#) = happyShift action_29+action_169 (97#) = happyShift action_30+action_169 (98#) = happyShift action_31+action_169 (6#) = happyGoto action_2+action_169 (7#) = happyGoto action_221+action_169 (9#) = happyGoto action_4+action_169 (16#) = happyGoto action_5+action_169 (17#) = happyGoto action_6+action_169 (18#) = happyGoto action_7+action_169 (21#) = happyGoto action_8+action_169 (24#) = happyGoto action_9+action_169 (25#) = happyGoto action_10+action_169 (26#) = happyGoto action_11+action_169 x = happyTcHack x happyFail++action_170 x = happyTcHack x happyReduce_114++action_171 x = happyTcHack x happyReduce_72++action_172 (37#) = happyShift action_220+action_172 x = happyTcHack x happyFail++action_173 (38#) = happyShift action_219+action_173 (72#) = happyShift action_122+action_173 x = happyTcHack x happyFail++action_174 x = happyTcHack x happyReduce_71++action_175 (37#) = happyShift action_218+action_175 x = happyTcHack x happyFail++action_176 (38#) = happyShift action_217+action_176 (72#) = happyShift action_122+action_176 x = happyTcHack x happyFail++action_177 (41#) = happyShift action_37+action_177 (42#) = happyShift action_38+action_177 (43#) = happyShift action_39+action_177 (44#) = happyShift action_40+action_177 (45#) = happyShift action_41+action_177 (46#) = happyShift action_42+action_177 (47#) = happyShift action_43+action_177 (48#) = happyShift action_44+action_177 (49#) = happyShift action_45+action_177 (50#) = happyShift action_46+action_177 (51#) = happyShift action_47+action_177 (52#) = happyShift action_48+action_177 (53#) = happyShift action_49+action_177 (54#) = happyShift action_50+action_177 (55#) = happyShift action_51+action_177 (56#) = happyShift action_52+action_177 (57#) = happyShift action_53+action_177 (58#) = happyShift action_54+action_177 (59#) = happyShift action_55+action_177 (60#) = happyShift action_56+action_177 (61#) = happyShift action_57+action_177 (62#) = happyShift action_58+action_177 (63#) = happyShift action_59+action_177 (64#) = happyShift action_60+action_177 (65#) = happyShift action_61+action_177 (66#) = happyShift action_62+action_177 (67#) = happyShift action_63+action_177 (68#) = happyShift action_64+action_177 x = happyTcHack x happyReduce_60++action_178 (73#) = happyShift action_216+action_178 x = happyTcHack x happyFail++action_179 (71#) = happyShift action_215+action_179 x = happyTcHack x happyFail++action_180 (41#) = happyShift action_37+action_180 (42#) = happyShift action_38+action_180 (43#) = happyShift action_39+action_180 (44#) = happyShift action_40+action_180 (45#) = happyShift action_41+action_180 (46#) = happyShift action_42+action_180 (47#) = happyShift action_43+action_180 (48#) = happyShift action_44+action_180 (49#) = happyShift action_45+action_180 (50#) = happyShift action_46+action_180 (51#) = happyShift action_47+action_180 (52#) = happyShift action_48+action_180 (53#) = happyShift action_49+action_180 (54#) = happyShift action_50+action_180 (55#) = happyShift action_51+action_180 (56#) = happyShift action_52+action_180 (57#) = happyShift action_53+action_180 (58#) = happyShift action_54+action_180 (59#) = happyShift action_55+action_180 (60#) = happyShift action_56+action_180 (61#) = happyShift action_57+action_180 (62#) = happyShift action_58+action_180 (63#) = happyShift action_59+action_180 (64#) = happyShift action_60+action_180 (65#) = happyShift action_61+action_180 (66#) = happyShift action_62+action_180 (67#) = happyShift action_63+action_180 (68#) = happyShift action_64+action_180 x = happyTcHack x happyReduce_56++action_181 (39#) = happyShift action_213+action_181 (98#) = happyShift action_214+action_181 x = happyTcHack x happyFail++action_182 (48#) = happyShift action_212+action_182 x = happyTcHack x happyFail++action_183 (41#) = happyShift action_37+action_183 (42#) = happyShift action_38+action_183 (43#) = happyShift action_39+action_183 (44#) = happyShift action_40+action_183 (45#) = happyShift action_41+action_183 (46#) = happyShift action_42+action_183 (47#) = happyShift action_43+action_183 (48#) = happyShift action_44+action_183 (49#) = happyShift action_45+action_183 (50#) = happyShift action_46+action_183 (51#) = happyShift action_47+action_183 (52#) = happyShift action_48+action_183 (53#) = happyShift action_49+action_183 (54#) = happyShift action_50+action_183 (55#) = happyShift action_51+action_183 (56#) = happyShift action_52+action_183 (57#) = happyShift action_53+action_183 (58#) = happyShift action_54+action_183 (59#) = happyShift action_55+action_183 (60#) = happyShift action_56+action_183 (61#) = happyShift action_57+action_183 (62#) = happyShift action_58+action_183 (63#) = happyShift action_59+action_183 (64#) = happyShift action_60+action_183 (65#) = happyShift action_61+action_183 (66#) = happyShift action_62+action_183 (67#) = happyShift action_63+action_183 (68#) = happyShift action_64+action_183 x = happyTcHack x happyReduce_51++action_184 (32#) = happyShift action_211+action_184 (41#) = happyShift action_37+action_184 (42#) = happyShift action_38+action_184 (43#) = happyShift action_39+action_184 (44#) = happyShift action_40+action_184 (45#) = happyShift action_41+action_184 (46#) = happyShift action_42+action_184 (47#) = happyShift action_43+action_184 (48#) = happyShift action_44+action_184 (49#) = happyShift action_45+action_184 (50#) = happyShift action_46+action_184 (51#) = happyShift action_47+action_184 (52#) = happyShift action_48+action_184 (53#) = happyShift action_49+action_184 (54#) = happyShift action_50+action_184 (55#) = happyShift action_51+action_184 (56#) = happyShift action_52+action_184 (57#) = happyShift action_53+action_184 (58#) = happyShift action_54+action_184 (59#) = happyShift action_55+action_184 (60#) = happyShift action_56+action_184 (61#) = happyShift action_57+action_184 (62#) = happyShift action_58+action_184 (63#) = happyShift action_59+action_184 (64#) = happyShift action_60+action_184 (65#) = happyShift action_61+action_184 (66#) = happyShift action_62+action_184 (67#) = happyShift action_63+action_184 (68#) = happyShift action_64+action_184 x = happyTcHack x happyFail++action_185 (41#) = happyShift action_37+action_185 (42#) = happyShift action_38+action_185 (43#) = happyShift action_39+action_185 (44#) = happyShift action_40+action_185 (45#) = happyShift action_41+action_185 (46#) = happyShift action_42+action_185 (47#) = happyShift action_43+action_185 (48#) = happyShift action_44+action_185 (49#) = happyShift action_45+action_185 (50#) = happyShift action_46+action_185 (51#) = happyShift action_47+action_185 (52#) = happyShift action_48+action_185 (53#) = happyShift action_49+action_185 (54#) = happyShift action_50+action_185 (55#) = happyShift action_51+action_185 (56#) = happyShift action_52+action_185 (57#) = happyShift action_53+action_185 (58#) = happyShift action_54+action_185 (59#) = happyShift action_55+action_185 (60#) = happyShift action_56+action_185 (61#) = happyShift action_57+action_185 (62#) = happyShift action_58+action_185 (63#) = happyShift action_59+action_185 (64#) = happyShift action_60+action_185 (65#) = happyShift action_61+action_185 (66#) = happyShift action_62+action_185 (67#) = happyShift action_63+action_185 (68#) = happyShift action_64+action_185 x = happyTcHack x happyReduce_11++action_186 (41#) = happyShift action_37+action_186 (42#) = happyShift action_38+action_186 (43#) = happyShift action_39+action_186 (44#) = happyShift action_40+action_186 (45#) = happyShift action_41+action_186 (46#) = happyShift action_42+action_186 (47#) = happyShift action_43+action_186 (48#) = happyShift action_44+action_186 (49#) = happyShift action_45+action_186 (50#) = happyShift action_46+action_186 (51#) = happyShift action_47+action_186 (52#) = happyShift action_48+action_186 (53#) = happyShift action_49+action_186 (54#) = happyShift action_50+action_186 (55#) = happyShift action_51+action_186 (56#) = happyShift action_52+action_186 (57#) = happyShift action_53+action_186 (58#) = happyShift action_54+action_186 (59#) = happyShift action_55+action_186 (60#) = happyShift action_56+action_186 (61#) = happyShift action_57+action_186 (62#) = happyShift action_58+action_186 (63#) = happyShift action_59+action_186 (64#) = happyShift action_60+action_186 (65#) = happyShift action_61+action_186 (66#) = happyShift action_62+action_186 (67#) = happyShift action_63+action_186 (68#) = happyShift action_64+action_186 x = happyTcHack x happyReduce_10++action_187 (71#) = happyShift action_209+action_187 (90#) = happyShift action_210+action_187 x = happyTcHack x happyFail++action_188 x = happyTcHack x happyReduce_106++action_189 (33#) = happyShift action_90+action_189 x = happyTcHack x happyReduce_102++action_190 (35#) = happyShift action_15+action_190 (44#) = happyShift action_18+action_190 (86#) = happyShift action_26+action_190 (92#) = happyShift action_27+action_190 (94#) = happyShift action_28+action_190 (6#) = happyGoto action_2+action_190 (24#) = happyGoto action_208+action_190 (25#) = happyGoto action_10+action_190 (26#) = happyGoto action_11+action_190 x = happyTcHack x happyFail++action_191 (33#) = happyShift action_90+action_191 x = happyTcHack x happyReduce_101++action_192 (52#) = happyShift action_207+action_192 x = happyTcHack x happyFail++action_193 (38#) = happyShift action_206+action_193 (72#) = happyShift action_122+action_193 x = happyTcHack x happyFail++action_194 x = happyTcHack x happyReduce_89++action_195 (28#) = happyShift action_12+action_195 (29#) = happyShift action_13+action_195 (30#) = happyShift action_14+action_195 (35#) = happyShift action_15+action_195 (42#) = happyShift action_16+action_195 (43#) = happyShift action_17+action_195 (44#) = happyShift action_18+action_195 (50#) = happyShift action_19+action_195 (65#) = happyShift action_20+action_195 (69#) = happyShift action_21+action_195 (70#) = happyShift action_22+action_195 (79#) = happyShift action_23+action_195 (80#) = happyShift action_24+action_195 (84#) = happyShift action_25+action_195 (86#) = happyShift action_26+action_195 (92#) = happyShift action_27+action_195 (94#) = happyShift action_28+action_195 (96#) = happyShift action_29+action_195 (97#) = happyShift action_30+action_195 (98#) = happyShift action_31+action_195 (6#) = happyGoto action_2+action_195 (7#) = happyGoto action_82+action_195 (8#) = happyGoto action_205+action_195 (9#) = happyGoto action_4+action_195 (16#) = happyGoto action_5+action_195 (17#) = happyGoto action_6+action_195 (18#) = happyGoto action_7+action_195 (21#) = happyGoto action_8+action_195 (24#) = happyGoto action_9+action_195 (25#) = happyGoto action_10+action_195 (26#) = happyGoto action_11+action_195 x = happyTcHack x happyFail++action_196 (86#) = happyShift action_204+action_196 x = happyTcHack x happyFail++action_197 x = happyTcHack x happyReduce_88++action_198 x = happyTcHack x happyReduce_87++action_199 (28#) = happyShift action_12+action_199 (29#) = happyShift action_13+action_199 (30#) = happyShift action_14+action_199 (35#) = happyShift action_15+action_199 (42#) = happyShift action_16+action_199 (43#) = happyShift action_17+action_199 (44#) = happyShift action_18+action_199 (50#) = happyShift action_19+action_199 (65#) = happyShift action_20+action_199 (69#) = happyShift action_21+action_199 (70#) = happyShift action_22+action_199 (79#) = happyShift action_23+action_199 (80#) = happyShift action_24+action_199 (84#) = happyShift action_25+action_199 (86#) = happyShift action_26+action_199 (92#) = happyShift action_27+action_199 (94#) = happyShift action_28+action_199 (96#) = happyShift action_29+action_199 (97#) = happyShift action_30+action_199 (98#) = happyShift action_31+action_199 (6#) = happyGoto action_2+action_199 (7#) = happyGoto action_202+action_199 (9#) = happyGoto action_4+action_199 (14#) = happyGoto action_203+action_199 (16#) = happyGoto action_5+action_199 (17#) = happyGoto action_6+action_199 (18#) = happyGoto action_7+action_199 (21#) = happyGoto action_8+action_199 (24#) = happyGoto action_9+action_199 (25#) = happyGoto action_10+action_199 (26#) = happyGoto action_11+action_199 x = happyTcHack x happyFail++action_200 (28#) = happyShift action_12+action_200 (29#) = happyShift action_13+action_200 (30#) = happyShift action_14+action_200 (35#) = happyShift action_15+action_200 (42#) = happyShift action_16+action_200 (43#) = happyShift action_17+action_200 (44#) = happyShift action_18+action_200 (50#) = happyShift action_19+action_200 (65#) = happyShift action_20+action_200 (69#) = happyShift action_21+action_200 (70#) = happyShift action_22+action_200 (79#) = happyShift action_23+action_200 (80#) = happyShift action_24+action_200 (84#) = happyShift action_25+action_200 (86#) = happyShift action_26+action_200 (92#) = happyShift action_27+action_200 (94#) = happyShift action_28+action_200 (96#) = happyShift action_29+action_200 (97#) = happyShift action_30+action_200 (98#) = happyShift action_31+action_200 (6#) = happyGoto action_2+action_200 (7#) = happyGoto action_201+action_200 (9#) = happyGoto action_4+action_200 (16#) = happyGoto action_5+action_200 (17#) = happyGoto action_6+action_200 (18#) = happyGoto action_7+action_200 (21#) = happyGoto action_8+action_200 (24#) = happyGoto action_9+action_200 (25#) = happyGoto action_10+action_200 (26#) = happyGoto action_11+action_200 x = happyTcHack x happyFail++action_201 (41#) = happyShift action_37+action_201 (42#) = happyShift action_38+action_201 (43#) = happyShift action_39+action_201 (44#) = happyShift action_40+action_201 (45#) = happyShift action_41+action_201 (46#) = happyShift action_42+action_201 (47#) = happyShift action_43+action_201 (48#) = happyShift action_44+action_201 (49#) = happyShift action_45+action_201 (50#) = happyShift action_46+action_201 (51#) = happyShift action_47+action_201 (52#) = happyShift action_48+action_201 (53#) = happyShift action_49+action_201 (54#) = happyShift action_50+action_201 (55#) = happyShift action_51+action_201 (56#) = happyShift action_52+action_201 (57#) = happyShift action_53+action_201 (58#) = happyShift action_54+action_201 (59#) = happyShift action_55+action_201 (60#) = happyShift action_56+action_201 (61#) = happyShift action_57+action_201 (62#) = happyShift action_58+action_201 (63#) = happyShift action_59+action_201 (64#) = happyShift action_60+action_201 (65#) = happyShift action_61+action_201 (66#) = happyShift action_62+action_201 (67#) = happyShift action_63+action_201 (68#) = happyShift action_64+action_201 x = happyTcHack x happyReduce_9++action_202 (41#) = happyShift action_37+action_202 (42#) = happyShift action_38+action_202 (43#) = happyShift action_39+action_202 (44#) = happyShift action_40+action_202 (45#) = happyShift action_41+action_202 (46#) = happyShift action_42+action_202 (47#) = happyShift action_43+action_202 (48#) = happyShift action_44+action_202 (49#) = happyShift action_45+action_202 (50#) = happyShift action_46+action_202 (51#) = happyShift action_47+action_202 (52#) = happyShift action_48+action_202 (53#) = happyShift action_49+action_202 (54#) = happyShift action_50+action_202 (55#) = happyShift action_51+action_202 (56#) = happyShift action_52+action_202 (57#) = happyShift action_53+action_202 (58#) = happyShift action_54+action_202 (59#) = happyShift action_55+action_202 (60#) = happyShift action_56+action_202 (61#) = happyShift action_57+action_202 (62#) = happyShift action_58+action_202 (63#) = happyShift action_59+action_202 (64#) = happyShift action_60+action_202 (65#) = happyShift action_61+action_202 (66#) = happyShift action_62+action_202 (67#) = happyShift action_63+action_202 (68#) = happyShift action_64+action_202 (77#) = happyShift action_243+action_202 (78#) = happyShift action_244+action_202 (15#) = happyGoto action_242+action_202 x = happyTcHack x happyReduce_70++action_203 (72#) = happyShift action_241+action_203 x = happyTcHack x happyReduce_64++action_204 (52#) = happyShift action_240+action_204 x = happyTcHack x happyFail++action_205 (38#) = happyShift action_239+action_205 (72#) = happyShift action_122+action_205 x = happyTcHack x happyFail++action_206 x = happyTcHack x happyReduce_82++action_207 x = happyTcHack x happyReduce_74++action_208 (33#) = happyShift action_90+action_208 x = happyTcHack x happyReduce_103++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 (65#) = happyShift action_20+action_209 (69#) = happyShift action_21+action_209 (70#) = happyShift action_22+action_209 (79#) = happyShift action_23+action_209 (80#) = happyShift action_24+action_209 (84#) = happyShift action_25+action_209 (86#) = happyShift action_26+action_209 (92#) = happyShift action_27+action_209 (94#) = happyShift action_28+action_209 (96#) = happyShift action_29+action_209 (97#) = happyShift action_30+action_209 (98#) = happyShift action_31+action_209 (6#) = happyGoto action_2+action_209 (7#) = happyGoto action_238+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 (94#) = happyShift action_28+action_210 (6#) = happyGoto action_237+action_210 x = happyTcHack x happyFail++action_211 (28#) = happyShift action_12+action_211 (29#) = happyShift action_13+action_211 (30#) = happyShift action_14+action_211 (35#) = happyShift action_15+action_211 (42#) = happyShift action_16+action_211 (43#) = happyShift action_17+action_211 (44#) = happyShift action_18+action_211 (50#) = happyShift action_19+action_211 (65#) = happyShift action_20+action_211 (69#) = happyShift action_21+action_211 (70#) = happyShift action_22+action_211 (79#) = happyShift action_23+action_211 (80#) = happyShift action_24+action_211 (84#) = happyShift action_25+action_211 (86#) = happyShift action_26+action_211 (92#) = happyShift action_27+action_211 (94#) = happyShift action_28+action_211 (96#) = happyShift action_29+action_211 (97#) = happyShift action_30+action_211 (98#) = happyShift action_31+action_211 (6#) = happyGoto action_2+action_211 (7#) = happyGoto action_236+action_211 (9#) = happyGoto action_4+action_211 (16#) = happyGoto action_5+action_211 (17#) = happyGoto action_6+action_211 (18#) = happyGoto action_7+action_211 (21#) = happyGoto action_8+action_211 (24#) = happyGoto action_9+action_211 (25#) = happyGoto action_10+action_211 (26#) = happyGoto action_11+action_211 x = happyTcHack x happyFail++action_212 (39#) = happyShift action_234+action_212 (98#) = happyShift action_235+action_212 x = happyTcHack x happyFail++action_213 (28#) = happyShift action_12+action_213 (29#) = happyShift action_13+action_213 (30#) = happyShift action_14+action_213 (35#) = happyShift action_15+action_213 (42#) = happyShift action_16+action_213 (43#) = happyShift action_17+action_213 (44#) = happyShift action_18+action_213 (50#) = happyShift action_19+action_213 (65#) = happyShift action_20+action_213 (69#) = happyShift action_21+action_213 (70#) = happyShift action_22+action_213 (79#) = happyShift action_23+action_213 (80#) = happyShift action_24+action_213 (84#) = happyShift action_25+action_213 (86#) = happyShift action_26+action_213 (92#) = happyShift action_27+action_213 (94#) = happyShift action_28+action_213 (96#) = happyShift action_29+action_213 (97#) = happyShift action_30+action_213 (98#) = happyShift action_31+action_213 (6#) = happyGoto action_2+action_213 (7#) = happyGoto action_233+action_213 (9#) = happyGoto action_4+action_213 (16#) = happyGoto action_5+action_213 (17#) = happyGoto action_6+action_213 (18#) = happyGoto action_7+action_213 (21#) = happyGoto action_8+action_213 (24#) = happyGoto action_9+action_213 (25#) = happyGoto action_10+action_213 (26#) = happyGoto action_11+action_213 x = happyTcHack x happyFail++action_214 x = happyTcHack x happyReduce_90++action_215 (28#) = happyShift action_12+action_215 (29#) = happyShift action_13+action_215 (30#) = happyShift action_14+action_215 (35#) = happyShift action_15+action_215 (42#) = happyShift action_16+action_215 (43#) = happyShift action_17+action_215 (44#) = happyShift action_18+action_215 (50#) = happyShift action_19+action_215 (65#) = happyShift action_20+action_215 (69#) = happyShift action_21+action_215 (70#) = happyShift action_22+action_215 (79#) = happyShift action_23+action_215 (80#) = happyShift action_24+action_215 (84#) = happyShift action_25+action_215 (86#) = happyShift action_26+action_215 (92#) = happyShift action_27+action_215 (94#) = happyShift action_28+action_215 (96#) = happyShift action_29+action_215 (97#) = happyShift action_30+action_215 (98#) = happyShift action_31+action_215 (6#) = happyGoto action_2+action_215 (7#) = happyGoto action_232+action_215 (9#) = happyGoto action_4+action_215 (16#) = happyGoto action_5+action_215 (17#) = happyGoto action_6+action_215 (18#) = happyGoto action_7+action_215 (21#) = happyGoto action_8+action_215 (24#) = happyGoto action_9+action_215 (25#) = happyGoto action_10+action_215 (26#) = happyGoto action_11+action_215 x = happyTcHack x happyFail++action_216 (28#) = happyShift action_12+action_216 (29#) = happyShift action_13+action_216 (30#) = happyShift action_14+action_216 (35#) = happyShift action_15+action_216 (42#) = happyShift action_16+action_216 (43#) = happyShift action_17+action_216 (44#) = happyShift action_18+action_216 (50#) = happyShift action_19+action_216 (65#) = happyShift action_20+action_216 (69#) = happyShift action_21+action_216 (70#) = happyShift action_22+action_216 (79#) = happyShift action_23+action_216 (80#) = happyShift action_24+action_216 (84#) = happyShift action_25+action_216 (86#) = happyShift action_26+action_216 (92#) = happyShift action_27+action_216 (94#) = happyShift action_28+action_216 (96#) = happyShift action_29+action_216 (97#) = happyShift action_30+action_216 (98#) = happyShift action_31+action_216 (6#) = happyGoto action_2+action_216 (7#) = happyGoto action_231+action_216 (9#) = happyGoto action_4+action_216 (16#) = happyGoto action_5+action_216 (17#) = happyGoto action_6+action_216 (18#) = happyGoto action_7+action_216 (21#) = happyGoto action_8+action_216 (24#) = happyGoto action_9+action_216 (25#) = happyGoto action_10+action_216 (26#) = happyGoto action_11+action_216 x = happyTcHack x happyFail++action_217 x = happyTcHack x happyReduce_78++action_218 (28#) = happyShift action_12+action_218 (29#) = happyShift action_13+action_218 (30#) = happyShift action_14+action_218 (35#) = happyShift action_15+action_218 (42#) = happyShift action_16+action_218 (43#) = happyShift action_17+action_218 (44#) = happyShift action_18+action_218 (50#) = happyShift action_19+action_218 (65#) = happyShift action_20+action_218 (69#) = happyShift action_21+action_218 (70#) = happyShift action_22+action_218 (79#) = happyShift action_23+action_218 (80#) = happyShift action_24+action_218 (84#) = happyShift action_25+action_218 (86#) = happyShift action_26+action_218 (92#) = happyShift action_27+action_218 (94#) = happyShift action_28+action_218 (96#) = happyShift action_29+action_218 (97#) = happyShift action_30+action_218 (98#) = happyShift action_31+action_218 (6#) = happyGoto action_2+action_218 (7#) = happyGoto action_82+action_218 (8#) = happyGoto action_230+action_218 (9#) = happyGoto action_4+action_218 (16#) = happyGoto action_5+action_218 (17#) = happyGoto action_6+action_218 (18#) = happyGoto action_7+action_218 (21#) = happyGoto action_8+action_218 (24#) = happyGoto action_9+action_218 (25#) = happyGoto action_10+action_218 (26#) = happyGoto action_11+action_218 x = happyTcHack x happyFail++action_219 x = happyTcHack x happyReduce_79++action_220 (28#) = happyShift action_12+action_220 (29#) = happyShift action_13+action_220 (30#) = happyShift action_14+action_220 (35#) = happyShift action_15+action_220 (42#) = happyShift action_16+action_220 (43#) = happyShift action_17+action_220 (44#) = happyShift action_18+action_220 (50#) = happyShift action_19+action_220 (65#) = happyShift action_20+action_220 (69#) = happyShift action_21+action_220 (70#) = happyShift action_22+action_220 (79#) = happyShift action_23+action_220 (80#) = happyShift action_24+action_220 (84#) = happyShift action_25+action_220 (86#) = happyShift action_26+action_220 (92#) = happyShift action_27+action_220 (94#) = happyShift action_28+action_220 (96#) = happyShift action_29+action_220 (97#) = happyShift action_30+action_220 (98#) = happyShift action_31+action_220 (6#) = happyGoto action_2+action_220 (7#) = happyGoto action_82+action_220 (8#) = happyGoto action_229+action_220 (9#) = happyGoto action_4+action_220 (16#) = happyGoto action_5+action_220 (17#) = happyGoto action_6+action_220 (18#) = happyGoto action_7+action_220 (21#) = happyGoto action_8+action_220 (24#) = happyGoto action_9+action_220 (25#) = happyGoto action_10+action_220 (26#) = happyGoto action_11+action_220 x = happyTcHack x happyFail++action_221 (41#) = happyShift action_37+action_221 (42#) = happyShift action_38+action_221 (43#) = happyShift action_39+action_221 (44#) = happyShift action_40+action_221 (45#) = happyShift action_41+action_221 (46#) = happyShift action_42+action_221 (47#) = happyShift action_43+action_221 (48#) = happyShift action_44+action_221 (49#) = happyShift action_45+action_221 (50#) = happyShift action_46+action_221 (51#) = happyShift action_47+action_221 (52#) = happyShift action_48+action_221 (53#) = happyShift action_49+action_221 (54#) = happyShift action_50+action_221 (55#) = happyShift action_51+action_221 (56#) = happyShift action_52+action_221 (57#) = happyShift action_53+action_221 (58#) = happyShift action_54+action_221 (59#) = happyShift action_55+action_221 (60#) = happyShift action_56+action_221 (61#) = happyShift action_57+action_221 (62#) = happyShift action_58+action_221 (63#) = happyShift action_59+action_221 (64#) = happyShift action_60+action_221 (65#) = happyShift action_61+action_221 (66#) = happyShift action_62+action_221 (67#) = happyShift action_63+action_221 (68#) = happyShift action_64+action_221 (93#) = happyShift action_228+action_221 x = happyTcHack x happyFail++action_222 (36#) = happyShift action_226+action_222 (72#) = happyShift action_227+action_222 x = happyTcHack x happyFail++action_223 x = happyTcHack x happyReduce_6++action_224 (37#) = happyShift action_225+action_224 x = happyTcHack x happyFail++action_225 (28#) = happyShift action_12+action_225 (29#) = happyShift action_13+action_225 (30#) = happyShift action_14+action_225 (35#) = happyShift action_15+action_225 (42#) = happyShift action_16+action_225 (43#) = happyShift action_17+action_225 (44#) = happyShift action_18+action_225 (50#) = happyShift action_19+action_225 (65#) = happyShift action_20+action_225 (69#) = happyShift action_21+action_225 (70#) = happyShift action_22+action_225 (79#) = happyShift action_23+action_225 (80#) = happyShift action_24+action_225 (84#) = happyShift action_25+action_225 (86#) = happyShift action_26+action_225 (92#) = happyShift action_27+action_225 (94#) = happyShift action_28+action_225 (96#) = happyShift action_29+action_225 (97#) = happyShift action_30+action_225 (98#) = happyShift action_31+action_225 (6#) = happyGoto action_2+action_225 (7#) = happyGoto action_254+action_225 (9#) = happyGoto action_4+action_225 (16#) = happyGoto action_5+action_225 (17#) = happyGoto action_6+action_225 (18#) = happyGoto action_7+action_225 (21#) = happyGoto action_8+action_225 (24#) = happyGoto action_9+action_225 (25#) = happyGoto action_10+action_225 (26#) = happyGoto action_11+action_225 x = happyTcHack x happyFail++action_226 (37#) = happyShift action_253+action_226 x = happyTcHack x happyFail++action_227 (94#) = happyShift action_28+action_227 (6#) = happyGoto action_252+action_227 x = happyTcHack x happyFail++action_228 (28#) = happyShift action_12+action_228 (29#) = happyShift action_13+action_228 (30#) = happyShift action_14+action_228 (35#) = happyShift action_15+action_228 (42#) = happyShift action_16+action_228 (43#) = happyShift action_17+action_228 (44#) = happyShift action_18+action_228 (50#) = happyShift action_19+action_228 (65#) = happyShift action_20+action_228 (69#) = happyShift action_21+action_228 (70#) = happyShift action_22+action_228 (79#) = happyShift action_23+action_228 (80#) = happyShift action_24+action_228 (84#) = happyShift action_25+action_228 (86#) = happyShift action_26+action_228 (87#) = happyShift action_34+action_228 (92#) = happyShift action_27+action_228 (94#) = happyShift action_28+action_228 (96#) = happyShift action_29+action_228 (97#) = happyShift action_30+action_228 (98#) = happyShift action_31+action_228 (4#) = happyGoto action_251+action_228 (6#) = happyGoto action_2+action_228 (7#) = happyGoto action_33+action_228 (9#) = happyGoto action_4+action_228 (16#) = happyGoto action_5+action_228 (17#) = happyGoto action_6+action_228 (18#) = happyGoto action_7+action_228 (21#) = happyGoto action_8+action_228 (24#) = happyGoto action_9+action_228 (25#) = happyGoto action_10+action_228 (26#) = happyGoto action_11+action_228 x = happyTcHack x happyFail++action_229 (38#) = happyShift action_250+action_229 (72#) = happyShift action_122+action_229 x = happyTcHack x happyFail++action_230 (38#) = happyShift action_249+action_230 (72#) = happyShift action_122+action_230 x = happyTcHack x happyFail++action_231 (41#) = happyShift action_37+action_231 (42#) = happyShift action_38+action_231 (43#) = happyShift action_39+action_231 (44#) = happyShift action_40+action_231 (45#) = happyShift action_41+action_231 (46#) = happyShift action_42+action_231 (47#) = happyShift action_43+action_231 (48#) = happyShift action_44+action_231 (49#) = happyShift action_45+action_231 (50#) = happyShift action_46+action_231 (51#) = happyShift action_47+action_231 (52#) = happyShift action_48+action_231 (53#) = happyShift action_49+action_231 (54#) = happyShift action_50+action_231 (55#) = happyShift action_51+action_231 (56#) = happyShift action_52+action_231 (57#) = happyShift action_53+action_231 (58#) = happyShift action_54+action_231 (59#) = happyShift action_55+action_231 (60#) = happyShift action_56+action_231 (61#) = happyShift action_57+action_231 (62#) = happyShift action_58+action_231 (63#) = happyShift action_59+action_231 (64#) = happyShift action_60+action_231 (65#) = happyShift action_61+action_231 (66#) = happyShift action_62+action_231 (67#) = happyShift action_63+action_231 (68#) = happyShift action_64+action_231 x = happyTcHack x happyReduce_61++action_232 (41#) = happyShift action_37+action_232 (42#) = happyShift action_38+action_232 (43#) = happyShift action_39+action_232 (44#) = happyShift action_40+action_232 (45#) = happyShift action_41+action_232 (46#) = happyShift action_42+action_232 (47#) = happyShift action_43+action_232 (48#) = happyShift action_44+action_232 (49#) = happyShift action_45+action_232 (50#) = happyShift action_46+action_232 (51#) = happyShift action_47+action_232 (52#) = happyShift action_48+action_232 (53#) = happyShift action_49+action_232 (54#) = happyShift action_50+action_232 (55#) = happyShift action_51+action_232 (56#) = happyShift action_52+action_232 (57#) = happyShift action_53+action_232 (58#) = happyShift action_54+action_232 (59#) = happyShift action_55+action_232 (60#) = happyShift action_56+action_232 (61#) = happyShift action_57+action_232 (62#) = happyShift action_58+action_232 (63#) = happyShift action_59+action_232 (64#) = happyShift action_60+action_232 (65#) = happyShift action_61+action_232 (66#) = happyShift action_62+action_232 (67#) = happyShift action_63+action_232 (68#) = happyShift action_64+action_232 x = happyTcHack x happyReduce_57++action_233 (40#) = happyShift action_248+action_233 (41#) = happyShift action_37+action_233 (42#) = happyShift action_38+action_233 (43#) = happyShift action_39+action_233 (44#) = happyShift action_40+action_233 (45#) = happyShift action_41+action_233 (46#) = happyShift action_42+action_233 (47#) = happyShift action_43+action_233 (48#) = happyShift action_44+action_233 (49#) = happyShift action_45+action_233 (50#) = happyShift action_46+action_233 (51#) = happyShift action_47+action_233 (52#) = happyShift action_48+action_233 (53#) = happyShift action_49+action_233 (54#) = happyShift action_50+action_233 (55#) = happyShift action_51+action_233 (56#) = happyShift action_52+action_233 (57#) = happyShift action_53+action_233 (58#) = happyShift action_54+action_233 (59#) = happyShift action_55+action_233 (60#) = happyShift action_56+action_233 (61#) = happyShift action_57+action_233 (62#) = happyShift action_58+action_233 (63#) = happyShift action_59+action_233 (64#) = happyShift action_60+action_233 (65#) = happyShift action_61+action_233 (66#) = happyShift action_62+action_233 (67#) = happyShift action_63+action_233 (68#) = happyShift action_64+action_233 x = happyTcHack x happyFail++action_234 (28#) = happyShift action_12+action_234 (29#) = happyShift action_13+action_234 (30#) = happyShift action_14+action_234 (35#) = happyShift action_15+action_234 (42#) = happyShift action_16+action_234 (43#) = happyShift action_17+action_234 (44#) = happyShift action_18+action_234 (50#) = happyShift action_19+action_234 (65#) = happyShift action_20+action_234 (69#) = happyShift action_21+action_234 (70#) = happyShift action_22+action_234 (79#) = happyShift action_23+action_234 (80#) = happyShift action_24+action_234 (84#) = happyShift action_25+action_234 (86#) = happyShift action_26+action_234 (92#) = happyShift action_27+action_234 (94#) = happyShift action_28+action_234 (96#) = happyShift action_29+action_234 (97#) = happyShift action_30+action_234 (98#) = happyShift action_31+action_234 (6#) = happyGoto action_2+action_234 (7#) = happyGoto action_247+action_234 (9#) = happyGoto action_4+action_234 (16#) = happyGoto action_5+action_234 (17#) = happyGoto action_6+action_234 (18#) = happyGoto action_7+action_234 (21#) = happyGoto action_8+action_234 (24#) = happyGoto action_9+action_234 (25#) = happyGoto action_10+action_234 (26#) = happyGoto action_11+action_234 x = happyTcHack x happyFail++action_235 x = happyTcHack x happyReduce_92++action_236 (41#) = happyShift action_37+action_236 (42#) = happyShift action_38+action_236 (43#) = happyShift action_39+action_236 (44#) = happyShift action_40+action_236 (45#) = happyShift action_41+action_236 (46#) = happyShift action_42+action_236 (47#) = happyShift action_43+action_236 (48#) = happyShift action_44+action_236 (49#) = happyShift action_45+action_236 (50#) = happyShift action_46+action_236 (51#) = happyShift action_47+action_236 (52#) = happyShift action_48+action_236 (53#) = happyShift action_49+action_236 (54#) = happyShift action_50+action_236 (55#) = happyShift action_51+action_236 (56#) = happyShift action_52+action_236 (57#) = happyShift action_53+action_236 (58#) = happyShift action_54+action_236 (59#) = happyShift action_55+action_236 (60#) = happyShift action_56+action_236 (61#) = happyShift action_57+action_236 (62#) = happyShift action_58+action_236 (63#) = happyShift action_59+action_236 (64#) = happyShift action_60+action_236 (65#) = happyShift action_61+action_236 (66#) = happyShift action_62+action_236 (67#) = happyShift action_63+action_236 (68#) = happyShift action_64+action_236 x = happyTcHack x happyReduce_12++action_237 (71#) = happyShift action_246+action_237 x = happyTcHack x happyFail++action_238 (41#) = happyShift action_37+action_238 (42#) = happyShift action_38+action_238 (43#) = happyShift action_39+action_238 (44#) = happyShift action_40+action_238 (45#) = happyShift action_41+action_238 (46#) = happyShift action_42+action_238 (47#) = happyShift action_43+action_238 (48#) = happyShift action_44+action_238 (49#) = happyShift action_45+action_238 (50#) = happyShift action_46+action_238 (51#) = happyShift action_47+action_238 (52#) = happyShift action_48+action_238 (53#) = happyShift action_49+action_238 (54#) = happyShift action_50+action_238 (55#) = happyShift action_51+action_238 (56#) = happyShift action_52+action_238 (57#) = happyShift action_53+action_238 (58#) = happyShift action_54+action_238 (59#) = happyShift action_55+action_238 (60#) = happyShift action_56+action_238 (61#) = happyShift action_57+action_238 (62#) = happyShift action_58+action_238 (63#) = happyShift action_59+action_238 (64#) = happyShift action_60+action_238 (65#) = happyShift action_61+action_238 (66#) = happyShift action_62+action_238 (67#) = happyShift action_63+action_238 (68#) = happyShift action_64+action_238 x = happyTcHack x happyReduce_58++action_239 x = happyTcHack x happyReduce_86++action_240 x = happyTcHack x happyReduce_73++action_241 (28#) = happyShift action_12+action_241 (29#) = happyShift action_13+action_241 (30#) = happyShift action_14+action_241 (35#) = happyShift action_15+action_241 (42#) = happyShift action_16+action_241 (43#) = happyShift action_17+action_241 (44#) = happyShift action_18+action_241 (50#) = happyShift action_19+action_241 (65#) = happyShift action_20+action_241 (69#) = happyShift action_21+action_241 (70#) = happyShift action_22+action_241 (79#) = happyShift action_23+action_241 (80#) = happyShift action_24+action_241 (84#) = happyShift action_25+action_241 (86#) = happyShift action_26+action_241 (92#) = happyShift action_27+action_241 (94#) = happyShift action_28+action_241 (96#) = happyShift action_29+action_241 (97#) = happyShift action_30+action_241 (98#) = happyShift action_31+action_241 (6#) = happyGoto action_2+action_241 (7#) = happyGoto action_245+action_241 (9#) = happyGoto action_4+action_241 (16#) = happyGoto action_5+action_241 (17#) = happyGoto action_6+action_241 (18#) = happyGoto action_7+action_241 (21#) = happyGoto action_8+action_241 (24#) = happyGoto action_9+action_241 (25#) = happyGoto action_10+action_241 (26#) = happyGoto action_11+action_241 x = happyTcHack x happyFail++action_242 x = happyTcHack x happyReduce_66++action_243 x = happyTcHack x happyReduce_68++action_244 x = happyTcHack x happyReduce_69++action_245 (41#) = happyShift action_37+action_245 (42#) = happyShift action_38+action_245 (43#) = happyShift action_39+action_245 (44#) = happyShift action_40+action_245 (45#) = happyShift action_41+action_245 (46#) = happyShift action_42+action_245 (47#) = happyShift action_43+action_245 (48#) = happyShift action_44+action_245 (49#) = happyShift action_45+action_245 (50#) = happyShift action_46+action_245 (51#) = happyShift action_47+action_245 (52#) = happyShift action_48+action_245 (53#) = happyShift action_49+action_245 (54#) = happyShift action_50+action_245 (55#) = happyShift action_51+action_245 (56#) = happyShift action_52+action_245 (57#) = happyShift action_53+action_245 (58#) = happyShift action_54+action_245 (59#) = happyShift action_55+action_245 (60#) = happyShift action_56+action_245 (61#) = happyShift action_57+action_245 (62#) = happyShift action_58+action_245 (63#) = happyShift action_59+action_245 (64#) = happyShift action_60+action_245 (65#) = happyShift action_61+action_245 (66#) = happyShift action_62+action_245 (67#) = happyShift action_63+action_245 (68#) = happyShift action_64+action_245 (77#) = happyShift action_243+action_245 (78#) = happyShift action_244+action_245 (15#) = happyGoto action_259+action_245 x = happyTcHack x happyReduce_70++action_246 (28#) = happyShift action_12+action_246 (29#) = happyShift action_13+action_246 (30#) = happyShift action_14+action_246 (35#) = happyShift action_15+action_246 (42#) = happyShift action_16+action_246 (43#) = happyShift action_17+action_246 (44#) = happyShift action_18+action_246 (50#) = happyShift action_19+action_246 (65#) = happyShift action_20+action_246 (69#) = happyShift action_21+action_246 (70#) = happyShift action_22+action_246 (79#) = happyShift action_23+action_246 (80#) = happyShift action_24+action_246 (84#) = happyShift action_25+action_246 (86#) = happyShift action_26+action_246 (92#) = happyShift action_27+action_246 (94#) = happyShift action_28+action_246 (96#) = happyShift action_29+action_246 (97#) = happyShift action_30+action_246 (98#) = happyShift action_31+action_246 (6#) = happyGoto action_2+action_246 (7#) = happyGoto action_258+action_246 (9#) = happyGoto action_4+action_246 (16#) = happyGoto action_5+action_246 (17#) = happyGoto action_6+action_246 (18#) = happyGoto action_7+action_246 (21#) = happyGoto action_8+action_246 (24#) = happyGoto action_9+action_246 (25#) = happyGoto action_10+action_246 (26#) = happyGoto action_11+action_246 x = happyTcHack x happyFail++action_247 (40#) = happyShift action_257+action_247 (41#) = happyShift action_37+action_247 (42#) = happyShift action_38+action_247 (43#) = happyShift action_39+action_247 (44#) = happyShift action_40+action_247 (45#) = happyShift action_41+action_247 (46#) = happyShift action_42+action_247 (47#) = happyShift action_43+action_247 (48#) = happyShift action_44+action_247 (49#) = happyShift action_45+action_247 (50#) = happyShift action_46+action_247 (51#) = happyShift action_47+action_247 (52#) = happyShift action_48+action_247 (53#) = happyShift action_49+action_247 (54#) = happyShift action_50+action_247 (55#) = happyShift action_51+action_247 (56#) = happyShift action_52+action_247 (57#) = happyShift action_53+action_247 (58#) = happyShift action_54+action_247 (59#) = happyShift action_55+action_247 (60#) = happyShift action_56+action_247 (61#) = happyShift action_57+action_247 (62#) = happyShift action_58+action_247 (63#) = happyShift action_59+action_247 (64#) = happyShift action_60+action_247 (65#) = happyShift action_61+action_247 (66#) = happyShift action_62+action_247 (67#) = happyShift action_63+action_247 (68#) = happyShift action_64+action_247 x = happyTcHack x happyFail++action_248 x = happyTcHack x happyReduce_91++action_249 x = happyTcHack x happyReduce_76++action_250 x = happyTcHack x happyReduce_77++action_251 x = happyTcHack x happyReduce_3++action_252 x = happyTcHack x happyReduce_7++action_253 (28#) = happyShift action_12+action_253 (29#) = happyShift action_13+action_253 (30#) = happyShift action_14+action_253 (35#) = happyShift action_15+action_253 (42#) = happyShift action_16+action_253 (43#) = happyShift action_17+action_253 (44#) = happyShift action_18+action_253 (50#) = happyShift action_19+action_253 (65#) = happyShift action_20+action_253 (69#) = happyShift action_21+action_253 (70#) = happyShift action_22+action_253 (79#) = happyShift action_23+action_253 (80#) = happyShift action_24+action_253 (84#) = happyShift action_25+action_253 (86#) = happyShift action_26+action_253 (92#) = happyShift action_27+action_253 (94#) = happyShift action_28+action_253 (96#) = happyShift action_29+action_253 (97#) = happyShift action_30+action_253 (98#) = happyShift action_31+action_253 (6#) = happyGoto action_2+action_253 (7#) = happyGoto action_256+action_253 (9#) = happyGoto action_4+action_253 (16#) = happyGoto action_5+action_253 (17#) = happyGoto action_6+action_253 (18#) = happyGoto action_7+action_253 (21#) = happyGoto action_8+action_253 (24#) = happyGoto action_9+action_253 (25#) = happyGoto action_10+action_253 (26#) = happyGoto action_11+action_253 x = happyTcHack x happyFail++action_254 (38#) = happyShift action_255+action_254 (41#) = happyShift action_37+action_254 (42#) = happyShift action_38+action_254 (43#) = happyShift action_39+action_254 (44#) = happyShift action_40+action_254 (45#) = happyShift action_41+action_254 (46#) = happyShift action_42+action_254 (47#) = happyShift action_43+action_254 (48#) = happyShift action_44+action_254 (49#) = happyShift action_45+action_254 (50#) = happyShift action_46+action_254 (51#) = happyShift action_47+action_254 (52#) = happyShift action_48+action_254 (53#) = happyShift action_49+action_254 (54#) = happyShift action_50+action_254 (55#) = happyShift action_51+action_254 (56#) = happyShift action_52+action_254 (57#) = happyShift action_53+action_254 (58#) = happyShift action_54+action_254 (59#) = happyShift action_55+action_254 (60#) = happyShift action_56+action_254 (61#) = happyShift action_57+action_254 (62#) = happyShift action_58+action_254 (63#) = happyShift action_59+action_254 (64#) = happyShift action_60+action_254 (65#) = happyShift action_61+action_254 (66#) = happyShift action_62+action_254 (67#) = happyShift action_63+action_254 (68#) = happyShift action_64+action_254 x = happyTcHack x happyFail++action_255 (93#) = happyShift action_261+action_255 x = happyTcHack x happyFail++action_256 (38#) = happyShift action_260+action_256 (41#) = happyShift action_37+action_256 (42#) = happyShift action_38+action_256 (43#) = happyShift action_39+action_256 (44#) = happyShift action_40+action_256 (45#) = happyShift action_41+action_256 (46#) = happyShift action_42+action_256 (47#) = happyShift action_43+action_256 (48#) = happyShift action_44+action_256 (49#) = happyShift action_45+action_256 (50#) = happyShift action_46+action_256 (51#) = happyShift action_47+action_256 (52#) = happyShift action_48+action_256 (53#) = happyShift action_49+action_256 (54#) = happyShift action_50+action_256 (55#) = happyShift action_51+action_256 (56#) = happyShift action_52+action_256 (57#) = happyShift action_53+action_256 (58#) = happyShift action_54+action_256 (59#) = happyShift action_55+action_256 (60#) = happyShift action_56+action_256 (61#) = happyShift action_57+action_256 (62#) = happyShift action_58+action_256 (63#) = happyShift action_59+action_256 (64#) = happyShift action_60+action_256 (65#) = happyShift action_61+action_256 (66#) = happyShift action_62+action_256 (67#) = happyShift action_63+action_256 (68#) = happyShift action_64+action_256 x = happyTcHack x happyFail++action_257 x = happyTcHack x happyReduce_93++action_258 (41#) = happyShift action_37+action_258 (42#) = happyShift action_38+action_258 (43#) = happyShift action_39+action_258 (44#) = happyShift action_40+action_258 (45#) = happyShift action_41+action_258 (46#) = happyShift action_42+action_258 (47#) = happyShift action_43+action_258 (48#) = happyShift action_44+action_258 (49#) = happyShift action_45+action_258 (50#) = happyShift action_46+action_258 (51#) = happyShift action_47+action_258 (52#) = happyShift action_48+action_258 (53#) = happyShift action_49+action_258 (54#) = happyShift action_50+action_258 (55#) = happyShift action_51+action_258 (56#) = happyShift action_52+action_258 (57#) = happyShift action_53+action_258 (58#) = happyShift action_54+action_258 (59#) = happyShift action_55+action_258 (60#) = happyShift action_56+action_258 (61#) = happyShift action_57+action_258 (62#) = happyShift action_58+action_258 (63#) = happyShift action_59+action_258 (64#) = happyShift action_60+action_258 (65#) = happyShift action_61+action_258 (66#) = happyShift action_62+action_258 (67#) = happyShift action_63+action_258 (68#) = happyShift action_64+action_258 x = happyTcHack x happyReduce_59++action_259 x = happyTcHack x happyReduce_67++action_260 (93#) = happyShift action_263+action_260 x = happyTcHack x happyFail++action_261 (28#) = happyShift action_12+action_261 (29#) = happyShift action_13+action_261 (30#) = happyShift action_14+action_261 (35#) = happyShift action_15+action_261 (42#) = happyShift action_16+action_261 (43#) = happyShift action_17+action_261 (44#) = happyShift action_18+action_261 (50#) = happyShift action_19+action_261 (65#) = happyShift action_20+action_261 (69#) = happyShift action_21+action_261 (70#) = happyShift action_22+action_261 (79#) = happyShift action_23+action_261 (80#) = happyShift action_24+action_261 (84#) = happyShift action_25+action_261 (86#) = happyShift action_26+action_261 (87#) = happyShift action_34+action_261 (92#) = happyShift action_27+action_261 (94#) = happyShift action_28+action_261 (96#) = happyShift action_29+action_261 (97#) = happyShift action_30+action_261 (98#) = happyShift action_31+action_261 (4#) = happyGoto action_262+action_261 (6#) = happyGoto action_2+action_261 (7#) = happyGoto action_33+action_261 (9#) = happyGoto action_4+action_261 (16#) = happyGoto action_5+action_261 (17#) = happyGoto action_6+action_261 (18#) = happyGoto action_7+action_261 (21#) = happyGoto action_8+action_261 (24#) = happyGoto action_9+action_261 (25#) = happyGoto action_10+action_261 (26#) = happyGoto action_11+action_261 x = happyTcHack x happyFail++action_262 x = happyTcHack x happyReduce_5++action_263 (28#) = happyShift action_12+action_263 (29#) = happyShift action_13+action_263 (30#) = happyShift action_14+action_263 (35#) = happyShift action_15+action_263 (42#) = happyShift action_16+action_263 (43#) = happyShift action_17+action_263 (44#) = happyShift action_18+action_263 (50#) = happyShift action_19+action_263 (65#) = happyShift action_20+action_263 (69#) = happyShift action_21+action_263 (70#) = happyShift action_22+action_263 (79#) = happyShift action_23+action_263 (80#) = happyShift action_24+action_263 (84#) = happyShift action_25+action_263 (86#) = happyShift action_26+action_263 (87#) = happyShift action_34+action_263 (92#) = happyShift action_27+action_263 (94#) = happyShift action_28+action_263 (96#) = happyShift action_29+action_263 (97#) = happyShift action_30+action_263 (98#) = happyShift action_31+action_263 (4#) = happyGoto action_264+action_263 (6#) = happyGoto action_2+action_263 (7#) = happyGoto action_33+action_263 (9#) = happyGoto action_4+action_263 (16#) = happyGoto action_5+action_263 (17#) = happyGoto action_6+action_263 (18#) = happyGoto action_7+action_263 (21#) = happyGoto action_8+action_263 (24#) = happyGoto action_9+action_263 (25#) = happyGoto action_10+action_263 (26#) = happyGoto action_11+action_263 x = happyTcHack x happyFail++action_264 x = happyTcHack x happyReduce_4++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 7# 4# happyReduction_3+happyReduction_3 (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 happyOut6 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + case happyOut4 happy_x_7 of { happy_var_7 -> + happyIn4+ ((Ast "variable" [happy_var_3,happy_var_5]):happy_var_7+ ) `HappyStk` happyRest}}}++happyReduce_4 = happyReduce 11# 4# happyReduction_4+happyReduction_4 (happy_x_11 `HappyStk`+ 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_11 of { happy_var_11 -> + happyIn4+ ((Ast "function" ([Avar happy_var_3,happy_var_8]++happy_var_5)):happy_var_11+ ) `HappyStk` happyRest}}}}++happyReduce_5 = happyReduce 10# 4# happyReduction_5+happyReduction_5 (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 happyOut7 happy_x_7 of { happy_var_7 -> + case happyOut4 happy_x_10 of { happy_var_10 -> + happyIn4+ ((Ast "function" ([Avar happy_var_3,happy_var_7])):happy_var_10+ ) `HappyStk` happyRest}}}++happyReduce_6 = happySpecReduce_1 5# happyReduction_6+happyReduction_6 happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn5+ ([happy_var_1]+ )}++happyReduce_7 = happySpecReduce_3 5# happyReduction_7+happyReduction_7 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_8 = happySpecReduce_1 6# happyReduction_8+happyReduction_8 happy_x_1+ = case happyOutTok happy_x_1 of { (Variable happy_var_1) -> + happyIn6+ (Avar happy_var_1+ )}++happyReduce_9 = happyReduce 5# 7# happyReduction_9+happyReduction_9 (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_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 "some" [happy_var_2 happy_var_4]+ ) `HappyStk` happyRest}}++happyReduce_11 = happyReduce 4# 7# happyReduction_11+happyReduction_11 (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_12 = happyReduce 6# 7# happyReduction_12+happyReduction_12 (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_13 = happySpecReduce_1 7# happyReduction_13+happyReduction_13 happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++happyReduce_14 = happySpecReduce_1 7# happyReduction_14+happyReduction_14 happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++happyReduce_15 = happySpecReduce_1 7# happyReduction_15+happyReduction_15 happy_x_1+ = case happyOut16 happy_x_1 of { happy_var_1 -> + happyIn7+ (happy_var_1+ )}++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 "to" [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 "*" [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 "div" [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 "idiv" [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 "mod" [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 ">=" [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 "<<" [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 ">>" [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 "is" [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 "eq" [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 "ne" [happy_var_1,happy_var_3]+ )}}++happyReduce_34 = happySpecReduce_3 7# happyReduction_34+happyReduction_34 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 "lt" [happy_var_1,happy_var_3]+ )}}++happyReduce_35 = happySpecReduce_3 7# happyReduction_35+happyReduction_35 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 "le" [happy_var_1,happy_var_3]+ )}}++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 happyOut7 happy_x_3 of { happy_var_3 -> + happyIn7+ (call "gt" [happy_var_1,happy_var_3]+ )}}++happyReduce_37 = happySpecReduce_3 7# happyReduction_37+happyReduction_37 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 "ge" [happy_var_1,happy_var_3]+ )}}++happyReduce_38 = happySpecReduce_3 7# happyReduction_38+happyReduction_38 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_39 = happySpecReduce_3 7# happyReduction_39+happyReduction_39 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_40 = happySpecReduce_3 7# happyReduction_40+happyReduction_40 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_41 = happySpecReduce_3 7# happyReduction_41+happyReduction_41 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_42 = happySpecReduce_3 7# happyReduction_42+happyReduction_42 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 "intersect" [happy_var_1,happy_var_3]+ )}}++happyReduce_43 = happySpecReduce_3 7# happyReduction_43+happyReduction_43 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_44 = happySpecReduce_2 7# happyReduction_44+happyReduction_44 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "uplus" [happy_var_2]+ )}++happyReduce_45 = happySpecReduce_2 7# happyReduction_45+happyReduction_45 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "uminus" [happy_var_2]+ )}++happyReduce_46 = happySpecReduce_2 7# happyReduction_46+happyReduction_46 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn7+ (call "not" [happy_var_2]+ )}++happyReduce_47 = happySpecReduce_1 7# happyReduction_47+happyReduction_47 happy_x_1+ = case happyOutTok happy_x_1 of { (TString happy_var_1) -> + happyIn7+ (Astring happy_var_1+ )}++happyReduce_48 = happySpecReduce_1 7# happyReduction_48+happyReduction_48 happy_x_1+ = case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> + happyIn7+ (Aint happy_var_1+ )}++happyReduce_49 = happySpecReduce_1 7# happyReduction_49+happyReduction_49 happy_x_1+ = case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> + happyIn7+ (Afloat happy_var_1+ )}++happyReduce_50 = happySpecReduce_1 8# happyReduction_50+happyReduction_50 happy_x_1+ = case happyOut7 happy_x_1 of { happy_var_1 -> + happyIn8+ ([happy_var_1]+ )}++happyReduce_51 = happySpecReduce_3 8# happyReduction_51+happyReduction_51 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_52 = happySpecReduce_2 9# happyReduction_52+happyReduction_52 happy_x_2+ happy_x_1+ = case happyOut10 happy_x_2 of { happy_var_2 -> + happyIn9+ (happy_var_2+ )}++happyReduce_53 = happySpecReduce_2 9# happyReduction_53+happyReduction_53 happy_x_2+ happy_x_1+ = case happyOut11 happy_x_2 of { happy_var_2 -> + happyIn9+ (happy_var_2+ )}++happyReduce_54 = happySpecReduce_3 9# happyReduction_54+happyReduction_54 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_55 = happySpecReduce_3 9# happyReduction_55+happyReduction_55 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_56 = happySpecReduce_3 10# happyReduction_56+happyReduction_56 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_57 = happyReduce 5# 10# happyReduction_57+happyReduction_57 (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 happyOut6 happy_x_3 of { happy_var_3 -> + case happyOut7 happy_x_5 of { happy_var_5 -> + happyIn10+ (\x -> Ast "for" [happy_var_1,happy_var_3,happy_var_5,x]+ ) `HappyStk` happyRest}}}++happyReduce_58 = happyReduce 5# 10# happyReduction_58+happyReduction_58 (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_59 = happyReduce 7# 10# happyReduction_59+happyReduction_59 (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 happyOut6 happy_x_5 of { happy_var_5 -> + case happyOut7 happy_x_7 of { happy_var_7 -> + happyIn10+ (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_5,happy_var_7,x])+ ) `HappyStk` happyRest}}}}++happyReduce_60 = happySpecReduce_3 11# happyReduction_60+happyReduction_60 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_61 = happyReduce 5# 11# happyReduction_61+happyReduction_61 (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_62 = happySpecReduce_2 12# happyReduction_62+happyReduction_62 happy_x_2+ happy_x_1+ = case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn12+ (\x -> Ast "predicate" [happy_var_2,x]+ )}++happyReduce_63 = happySpecReduce_0 12# happyReduction_63+happyReduction_63 = happyIn12+ (id+ )++happyReduce_64 = happySpecReduce_3 13# happyReduction_64+happyReduction_64 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut14 happy_x_3 of { happy_var_3 -> + happyIn13+ ((\x -> Ast "sortTuple" (x:(fst happy_var_3)),+ \x -> Ast "sort" (x:(snd happy_var_3)))+ )}++happyReduce_65 = happySpecReduce_0 13# happyReduction_65+happyReduction_65 = happyIn13+ ((id,id)+ )++happyReduce_66 = happySpecReduce_2 14# happyReduction_66+happyReduction_66 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_67 = happyReduce 4# 14# happyReduction_67+happyReduction_67 (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_68 = happySpecReduce_1 15# happyReduction_68+happyReduction_68 happy_x_1+ = happyIn15+ (Avar "ascending"+ )++happyReduce_69 = happySpecReduce_1 15# happyReduction_69+happyReduction_69 happy_x_1+ = happyIn15+ (Avar "descending"+ )++happyReduce_70 = happySpecReduce_0 15# happyReduction_70+happyReduction_70 = happyIn15+ (Avar "ascending"+ )++happyReduce_71 = happyReduce 4# 16# happyReduction_71+happyReduction_71 (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_72 = happyReduce 4# 16# happyReduction_72+happyReduction_72 (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_73 = happyReduce 6# 17# happyReduction_73+happyReduction_73 (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_74 = happyReduce 5# 17# happyReduction_74+happyReduction_74 (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_75 = happySpecReduce_2 17# happyReduction_75+happyReduction_75 happy_x_2+ happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + happyIn17+ (Ast "construction" (happy_var_1++[call "empty" []])+ )}++happyReduce_76 = happyReduce 7# 17# happyReduction_76+happyReduction_76 (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 happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_6 of { happy_var_6 -> + happyIn17+ (Ast "element_construction" [happy_var_3,concatenateAll happy_var_6]+ ) `HappyStk` happyRest}}++happyReduce_77 = happyReduce 7# 17# happyReduction_77+happyReduction_77 (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 happyOut7 happy_x_3 of { happy_var_3 -> + case happyOut8 happy_x_6 of { happy_var_6 -> + happyIn17+ (Ast "attribute_construction" [happy_var_3,concatenateAll happy_var_6]+ ) `HappyStk` happyRest}}++happyReduce_78 = happyReduce 5# 17# happyReduction_78+happyReduction_78 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_2 of { (QName happy_var_2) -> + case happyOut8 happy_x_4 of { happy_var_4 -> + happyIn17+ (Ast "element_construction" [Astring happy_var_2,concatenateAll happy_var_4]+ ) `HappyStk` happyRest}}++happyReduce_79 = happyReduce 5# 17# happyReduction_79+happyReduction_79 (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_2 of { (QName happy_var_2) -> + case happyOut8 happy_x_4 of { happy_var_4 -> + happyIn17+ (Ast "attribute_construction" [Astring happy_var_2,concatenateAll happy_var_4]+ ) `HappyStk` happyRest}}++happyReduce_80 = happySpecReduce_2 18# happyReduction_80+happyReduction_80 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_2 of { (QName happy_var_2) -> + happyIn18+ ([Astring happy_var_2,Ast "attributes" []]+ )}++happyReduce_81 = happySpecReduce_3 18# happyReduction_81+happyReduction_81 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_82 = happySpecReduce_3 19# happyReduction_82+happyReduction_82 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn19+ ([concatenateAll happy_var_2]+ )}++happyReduce_83 = happySpecReduce_1 19# happyReduction_83+happyReduction_83 happy_x_1+ = case happyOutTok happy_x_1 of { (TString happy_var_1) -> + happyIn19+ ([Astring happy_var_1]+ )}++happyReduce_84 = happySpecReduce_1 19# happyReduction_84+happyReduction_84 happy_x_1+ = case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> + happyIn19+ ([Astring happy_var_1]+ )}++happyReduce_85 = happySpecReduce_1 19# happyReduction_85+happyReduction_85 happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn19+ ([happy_var_1]+ )}++happyReduce_86 = happyReduce 4# 19# happyReduction_86+happyReduction_86 (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++[concatenateAll happy_var_3]+ ) `HappyStk` happyRest}}++happyReduce_87 = happySpecReduce_2 19# happyReduction_87+happyReduction_87 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_88 = happySpecReduce_2 19# happyReduction_88+happyReduction_88 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_89 = happySpecReduce_2 19# happyReduction_89+happyReduction_89 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_90 = happySpecReduce_3 20# happyReduction_90+happyReduction_90 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_91 = happyReduce 5# 20# happyReduction_91+happyReduction_91 (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_92 = happyReduce 4# 20# happyReduction_92+happyReduction_92 (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+ (happy_var_1++[Ast "pair" [Astring happy_var_2,Astring happy_var_4]]+ ) `HappyStk` happyRest}}}++happyReduce_93 = happyReduce 6# 20# happyReduction_93+happyReduction_93 (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+ (happy_var_1++[Ast "pair" [Astring happy_var_2,happy_var_5]]+ ) `HappyStk` happyRest}}}++happyReduce_94 = happySpecReduce_1 21# happyReduction_94+happyReduction_94 happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn21+ (Ast "step" (happy_var_1 "child_step" (Avar "."))+ )}++happyReduce_95 = happySpecReduce_2 21# happyReduction_95+happyReduction_95 happy_x_2+ happy_x_1+ = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn21+ (Ast "step" (happy_var_2 "attribute_step" (Avar "."))+ )}++happyReduce_96 = happySpecReduce_2 21# happyReduction_96+happyReduction_96 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+ (Ast "step" [happy_var_2 (Ast "step" (happy_var_1 "child_step" (Avar ".")))]+ )}}++happyReduce_97 = happySpecReduce_3 21# happyReduction_97+happyReduction_97 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+ (Ast "step" (map happy_var_3 (happy_var_2 "attribute_step" (Avar ".")))+ )}}++happyReduce_98 = happySpecReduce_1 22# happyReduction_98+happyReduction_98 happy_x_1+ = case happyOut23 happy_x_1 of { happy_var_1 -> + happyIn22+ (happy_var_1+ )}++happyReduce_99 = happySpecReduce_2 22# happyReduction_99+happyReduction_99 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_100 = happySpecReduce_2 23# happyReduction_100+happyReduction_100 happy_x_2+ happy_x_1+ = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn23+ (\e -> Ast "step" (happy_var_2 "child_step" e)+ )}++happyReduce_101 = happySpecReduce_3 23# happyReduction_101+happyReduction_101 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23+ (\e -> Ast "step" (happy_var_3 "attribute_step" e)+ )}++happyReduce_102 = happySpecReduce_3 23# happyReduction_102+happyReduction_102 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23+ (\e -> Ast "step" (happy_var_3 "descendant_step" e)+ )}++happyReduce_103 = happyReduce 4# 23# happyReduction_103+happyReduction_103 (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 -> Ast "step" (happy_var_4 "attribute_descendant_step" e)+ ) `HappyStk` happyRest}++happyReduce_104 = happySpecReduce_2 23# happyReduction_104+happyReduction_104 happy_x_2+ happy_x_1+ = happyIn23+ (\e -> Ast "step" [Ast "parent_step" [e]]+ )++happyReduce_105 = happySpecReduce_1 24# happyReduction_105+happyReduction_105 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn24+ (\t e -> [happy_var_1 t e]+ )}++happyReduce_106 = happyReduce 4# 24# happyReduction_106+happyReduction_106 (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 -> (happy_var_1 t e)++[happy_var_3]+ ) `HappyStk` happyRest}}++happyReduce_107 = happySpecReduce_1 25# happyReduction_107+happyReduction_107 happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn25+ (\t e -> happy_var_1 t e+ )}++happyReduce_108 = happySpecReduce_1 25# happyReduction_108+happyReduction_108 happy_x_1+ = happyIn25+ (\t e -> Ast t [Astring "*",e]+ )++happyReduce_109 = happySpecReduce_1 25# happyReduction_109+happyReduction_109 happy_x_1+ = case happyOutTok happy_x_1 of { (QName happy_var_1) -> + happyIn25+ (\t e -> Ast t [Astring happy_var_1,e]+ )}++happyReduce_110 = happySpecReduce_1 26# happyReduction_110+happyReduction_110 happy_x_1+ = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn26+ (\_ _ -> happy_var_1+ )}++happyReduce_111 = happySpecReduce_1 26# happyReduction_111+happyReduction_111 happy_x_1+ = happyIn26+ (\_ e -> e+ )++happyReduce_112 = happySpecReduce_3 26# happyReduction_112+happyReduction_112 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn26+ (\_ e -> if e == Avar "."+ then concatenateAll happy_var_2+ else Ast "context" [e,concatenateAll happy_var_2]+ )}++happyReduce_113 = happySpecReduce_2 26# happyReduction_113+happyReduction_113 happy_x_2+ happy_x_1+ = happyIn26+ (\_ _ -> call "empty" []+ )++happyReduce_114 = happyReduce 4# 26# happyReduction_114+happyReduction_114 (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+ (\_ e -> if e == Avar "."+ then call happy_var_1 happy_var_3+ else Ast "context" [e,call happy_var_1 happy_var_3]+ ) `HappyStk` happyRest}}++happyReduce_115 = happySpecReduce_3 26# happyReduction_115+happyReduction_115 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 99# 99# 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#;+ TNE -> cont 49#;+ TLT -> cont 50#;+ TLE -> cont 51#;+ TGT -> cont 52#;+ TGE -> cont 53#;+ PRE -> cont 54#;+ POST -> cont 55#;+ IS -> cont 56#;+ SEQ -> cont 57#;+ SNE -> cont 58#;+ SLT -> cont 59#;+ SLE -> cont 60#;+ SGT -> cont 61#;+ SGE -> cont 62#;+ AND -> cont 63#;+ OR -> cont 64#;+ NOT -> cont 65#;+ UNION -> cont 66#;+ INTERSECT -> cont 67#;+ EXCEPT -> cont 68#;+ FOR -> cont 69#;+ LET -> cont 70#;+ IN -> cont 71#;+ COMMA -> cont 72#;+ ASSIGN -> cont 73#;+ WHERE -> cont 74#;+ ORDER -> cont 75#;+ BY -> cont 76#;+ ASCENDING -> cont 77#;+ DESCENDING -> cont 78#;+ ELEMENT -> cont 79#;+ ATTRIBUTE -> cont 80#;+ STAG -> cont 81#;+ ETAG -> cont 82#;+ SATISFIES -> cont 83#;+ ATSIGN -> cont 84#;+ SLASH -> cont 85#;+ QName happy_dollar_dollar -> cont 86#;+ DECLARE -> cont 87#;+ FUNCTION -> cont 88#;+ VARIABLE -> cont 89#;+ AT -> cont 90#;+ DOTS -> cont 91#;+ DOT -> cont 92#;+ SEMI -> cont 93#;+ Variable happy_dollar_dollar -> cont 94#;+ XMLtext happy_dollar_dollar -> cont 95#;+ TInteger happy_dollar_dollar -> cont 96#;+ TFloat happy_dollar_dollar -> cont 97#;+ TString happy_dollar_dollar -> cont 98#;+ _ -> 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)+++concatenateAll :: [Ast] -> Ast+concatenateAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs+concatenateAll _ = call "empty" []+++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 | TNE | TLT | TLE | TGT | TGE | SEQ | SNE | SLT | SLE | SGT | SGE+ | AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA+ | ASSIGN | WHERE | ORDER | BY | ASCENDING | DESCENDING | ELEMENT+ | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN | SLASH | DECLARE | SEMI+ | FUNCTION | VARIABLE |AT | DOT | DOTS | TokenEOF | PRE | POST | IS+ | 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 syntax and returns an XMLtext token with the 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 n = xmlComment cs (text++"<!-") 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 ('\"':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)+xml ('(':':':cs) text n = xqComment cs text n+xml (c:cs) text n = xml cs (text++[c]) n+xml [] text _ = xmlText text++xqComment (':':')':cs) text n = xml cs text n+xqComment (_:cs) text n = xqComment cs text n+xqComment [] text _ = xmlText text++xmlComment ('-':'>':cs) text n = xml cs (text++"->") n+xmlComment (c:cs) text n = xmlComment cs (text++[c]) n+xmlComment [] 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 = LESCAPE : lexer cs n+lexer (':':'=':cs) n = ASSIGN : lexer cs n+lexer ('<':'/':cs) n = STAG : lexer cs n+lexer ('<':'=':cs) n = TLE : lexer cs n+lexer ('>':'=':cs) n = TGE : lexer cs n+lexer ('<':'<':cs) n = PRE : lexer cs n+lexer ('>':'>':cs) n = POST : lexer cs n+lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)+lexer ('(':':':cs) n = lexComment cs n+lexer ('<':'!':'-':cs) n = lexXmlComment cs "<!-" 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 = RESCAPE : lexer cs n+lexer ('!':'=':cs) n = TNE : lexer cs n+lexer ('\'':cs) n = lexString cs n+lexer ('\"':cs) n = lexString2 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 : lexer cs [n]+lexer ('}':cs) (_:n:ns) = RSB : (if n==0 then lexer cs (n:ns) else xml cs "" (n:ns))+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 (0: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 (0:n)+lexer ('|':cs) n = UNION : 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 /= '.'+ then TInteger (read k) : lexer rest n+ else let (m,rest2) = span isDigit (tail rest)+ val::Float = read (k++('.':m))+ in case rest2 of+ ('e':rest3) -> let (exp,rest4) = span isDigit rest3+ in (TFloat (val*10^(read exp))) : lexer rest4 n+ _ -> (TFloat val) : lexer rest2 n+ where (k,rest) = span isDigit cs++lexString cs n = TString s : lexer (tail rest) n+ where (s,rest) = span inString cs+ inString c = c /= '\''++lexString2 cs n = TString s : lexer (tail rest) n+ where (s,rest) = span inString cs+ inString c = c /= '\"'++lexComment (':':')':cs) n = lexer cs n+lexComment (_:cs) n = lexComment cs n+lexComment [] n = []++lexXmlComment ('-':'>':cs) text n = (xmlText (text++"->"))++(lexer cs n)+lexXmlComment (c:cs) text n = lexXmlComment cs (text++[c]) n+lexXmlComment [] text _ = xmlText text++lexVar cs n =+ case span isQN cs of+ ("return",rest) -> RETURN : lexer rest n+ ("some",rest) -> SOME : lexer rest n+ ("every",rest) -> EVERY : lexer rest n+ ("if",rest) -> IF : lexer rest n+ ("then",rest) -> THEN : lexer rest n+ ("else",rest) -> ELSE : lexer rest n+ ("to",rest) -> TO : lexer rest n+ ("div",rest) -> DIV : lexer rest n+ ("idiv",rest) -> IDIV : lexer rest n+ ("mod",rest) -> MOD : lexer rest n+ ("and",rest) -> AND : lexer rest n+ ("or",rest) -> OR : lexer rest n+ ("not",rest) -> NOT : lexer rest n+ ("union",rest) -> UNION : lexer rest n+ ("intersect",rest) -> INTERSECT : lexer rest n+ ("except",rest) -> EXCEPT : lexer rest n+ ("for",rest) -> FOR : lexer rest n+ ("let",rest) -> LET : lexer rest n+ ("in",rest) -> IN : lexer rest n+ ("where",rest) -> WHERE : lexer rest n+ ("order",rest) -> ORDER : lexer rest n+ ("by",rest) -> BY : lexer rest n+ ("ascending",rest) -> ASCENDING : lexer rest n+ ("descending",rest) -> DESCENDING : lexer rest n+ ("element",rest) -> ELEMENT : lexer rest n+ ("attribute",rest) -> ATTRIBUTE : lexer rest n+ ("satisfies",rest) -> SATISFIES : lexer rest n+ ("declare",rest) -> DECLARE : lexer rest n+ ("function",rest) -> FUNCTION : lexer rest n+ ("variable",rest) -> VARIABLE : lexer rest n+ ("at",rest) -> AT : lexer rest n+ ("eq",rest) -> SEQ : lexer rest n+ ("ne",rest) -> SNE : lexer rest n+ ("lt",rest) -> SLT : lexer rest n+ ("le",rest) -> SLE : lexer rest n+ ("gt",rest) -> SGT : lexer rest n+ ("ge",rest) -> SGE : lexer rest n+ ("is",rest) -> IS : lexer rest n+ (var,rest) -> QName var : lexer rest n+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp ++{-# LINE 28 "templates/GenericTemplate.hs" #-}+++++++++{-# LINE 49 "templates/GenericTemplate.hs" #-}++{-# LINE 59 "templates/GenericTemplate.hs" #-}++{-# LINE 68 "templates/GenericTemplate.hs" #-}++infixr 9 `HappyStk`+data HappyStk a = HappyStk a (HappyStk a)++-----------------------------------------------------------------------------+-- starting the parse++happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll++-----------------------------------------------------------------------------+-- Accepting the parse++-- If the current token is 1#, it means we've just accepted a partial+-- parse (a %partial parser). We must ignore the saved token on the top of+-- the stack in this case.+happyAccept 1# tk st sts (_ `HappyStk` ans `HappyStk` _) =+ happyReturn1 ans+happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j ) (happyReturn1 ans)++-----------------------------------------------------------------------------+-- Arrays only: do the next action++{-# LINE 155 "templates/GenericTemplate.hs" #-}++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++++newtype HappyState b c = HappyState+ (Int# -> -- token number+ Int# -> -- token number (yes, again)+ b -> -- token semantic value+ HappyState b c -> -- current state+ [HappyState b c] -> -- state stack+ c)++++-----------------------------------------------------------------------------+-- Shifting a token++happyShift new_state 1# tk st sts stk@(x `HappyStk` _) =+ let i = (case unsafeCoerce# x of { (I# (i)) -> i }) in+-- trace "shifting the error token" $+ new_state i i tk (HappyState (new_state)) ((st):(sts)) (stk)++happyShift new_state i tk st sts stk =+ happyNewToken new_state ((st):(sts)) ((happyInTok (tk))`HappyStk`stk)++-- happyReduce is specialised for the common cases.++happySpecReduce_0 i fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happySpecReduce_0 nt fn j tk st@((HappyState (action))) sts stk+ = action nt j tk st ((st):(sts)) (fn `HappyStk` stk)++happySpecReduce_1 i fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happySpecReduce_1 nt fn j tk _ sts@(((st@(HappyState (action))):(_))) (v1`HappyStk`stk')+ = let r = fn v1 in+ happySeq r (action nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_2 i fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happySpecReduce_2 nt fn j tk _ ((_):(sts@(((st@(HappyState (action))):(_))))) (v1`HappyStk`v2`HappyStk`stk')+ = let r = fn v1 v2 in+ happySeq r (action nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_3 i fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happySpecReduce_3 nt fn j tk _ ((_):(((_):(sts@(((st@(HappyState (action))):(_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')+ = let r = fn v1 v2 v3 in+ happySeq r (action nt j tk st sts (r `HappyStk` stk'))++happyReduce k i fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happyReduce k nt fn j tk st sts stk+ = case happyDrop (k -# (1# :: Int#)) sts of+ sts1@(((st1@(HappyState (action))):(_))) ->+ let r = fn stk in -- it doesn't hurt to always seq here...+ happyDoSeq r (action nt j tk st1 sts1 r)++happyMonadReduce k nt fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happyMonadReduce k nt fn j tk st sts stk =+ happyThen1 (fn stk tk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk))+ where sts1@(((st1@(HappyState (action))):(_))) = happyDrop k ((st):(sts))+ drop_stk = happyDropStk k stk++happyMonad2Reduce k nt fn 1# tk st sts stk+ = happyFail 1# tk st sts stk+happyMonad2Reduce k nt fn j tk st sts stk =+ happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))+ where sts1@(((st1@(HappyState (action))):(_))) = happyDrop k ((st):(sts))+ drop_stk = happyDropStk k stk++++++ new_state = action+++happyDrop 0# l = l+happyDrop n ((_):(t)) = happyDrop (n -# (1# :: Int#)) t++happyDropStk 0# l = l+happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::Int#)) xs++-----------------------------------------------------------------------------+-- Moving to a new state after a reduction++{-# LINE 253 "templates/GenericTemplate.hs" #-}+happyGoto action j tk st = action j j tk (HappyState action)+++-----------------------------------------------------------------------------+-- Error recovery (1# is the error token)++-- parse error if we are in recovery and we fail again+happyFail 1# tk old_st _ stk =+-- trace "failing" $ + happyError_ tk++{- We don't need state discarding for our restricted implementation of+ "error". In fact, it can cause some bogus parses, so I've disabled it+ for now --SDM++-- discard a state+happyFail 1# tk old_st (((HappyState (action))):(sts)) + (saved_tok `HappyStk` _ `HappyStk` stk) =+-- trace ("discarding state, depth " ++ show (length stk)) $+ action 1# 1# tk (HappyState (action)) sts ((saved_tok`HappyStk`stk))+-}++-- Enter error recovery: generate an error token,+-- save the old token and carry on.+happyFail i tk (HappyState (action)) sts stk =+-- trace "entering error recovery" $+ action 1# 1# tk (HappyState (action)) sts ( (unsafeCoerce# (I# (i))) `HappyStk` stk)++-- Internal happy errors:++notHappyAtAll = error "Internal Happy error\n"++-----------------------------------------------------------------------------+-- Hack to get the typechecker to accept our action functions+++happyTcHack :: Int# -> a -> a+happyTcHack x y = y+{-# INLINE happyTcHack #-}+++-----------------------------------------------------------------------------+-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq+-- otherwise it emits+-- happySeq = happyDontSeq++happyDoSeq, happyDontSeq :: a -> b -> b+happyDoSeq a b = a `seq` b+happyDontSeq a b = b++-----------------------------------------------------------------------------+-- Don't inline any functions from the template. GHC has a nasty habit+-- of deciding to inline happyGoto everywhere, which increases the size of+-- the generated parser quite a bit.++{-# LINE 317 "templates/GenericTemplate.hs" #-} {-# NOINLINE happyShift #-} {-# NOINLINE happySpecReduce_0 #-} {-# NOINLINE happySpecReduce_1 #-}
XQueryParser.y view
@@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/-- Creation: 02/15/08, last update: 03/25/08+- Creation: 02/15/08, last update: 03/30/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.@@ -45,11 +45,20 @@ 'idiv' { IDIV } 'mod' { MOD } '=' { TEQ }- '!=' { TNEQ }+ '!=' { TNE } '<' { TLT }- '<=' { LEQ }+ '<=' { TLE } '>' { TGT }- '>=' { GEQ }+ '>=' { TGE }+ '<<' { PRE }+ '>>' { POST }+ 'is' { IS }+ 'eq' { SEQ }+ 'ne' { SNE }+ 'lt' { SLT }+ 'le' { SLE }+ 'gt' { SGT }+ 'ge' { SGE } 'and' { AND } 'or' { OR } 'not' { NOT }@@ -74,12 +83,13 @@ '@' { ATSIGN } '/' { SLASH } 'QName' { QName $$ }- 'define' { DEFINE }+ 'declare' { DECLARE } 'function' { FUNCTION }+ 'variable' { VARIABLE } 'at' { AT } '..' { DOTS } '.' { DOT }- ';' { SEMI }+ ';' { SEMI } 'Variable' { Variable $$ } 'XMLtext' { XMLtext $$ } 'Integer' { TInteger $$ }@@ -94,7 +104,7 @@ %right 'and' %nonassoc 'not' %left 'to'-%left '=' '<' '>' '<=' '>=' '!='+%left '=' '<' '>' '<=' '>=' '!=' '>>' '<<' 'is' 'eq' 'ne' 'lt' 'le' 'gt' 'ge' %left '+' '-' %left '*' 'div' 'idiv' 'mod' %nonassoc UMINUS@@ -103,15 +113,18 @@ %% 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 }+ | 'declare' 'variable' var+ ':=' expr ';' prog { (Ast "variable" [$3,$5]):$7 }+ | 'declare' 'function' 'QName'+ '(' params ')' + '{' expr '}' ';' prog { (Ast "function" ([Avar $3,$8]++$5)):$11 }+ | 'declare' 'function' 'QName'+ '(' ')' '{' expr '}' ';' prog { (Ast "function" ([Avar $3,$7])):$10 } params : var { [$1] } | params ',' var { $1++[$3] } -var : 'Variable' { Avar $1 }+var : 'Variable' { Avar $1 } expr : clauses opt_where opt_order 'return' expr { (snd $3) ($1 ($2 ((fst $3) $5))) }@@ -136,11 +149,20 @@ | expr '<=' expr { call "<=" [$1,$3] } | expr '>' expr { call ">" [$1,$3] } | expr '>=' expr { call ">=" [$1,$3] }+ | expr '<<' expr { call "<<" [$1,$3] }+ | expr '>>' expr { call ">>" [$1,$3] }+ | expr 'is' expr { call "is" [$1,$3] }+ | expr 'eq' expr { call "eq" [$1,$3] }+ | expr 'ne' expr { call "ne" [$1,$3] }+ | expr 'lt' expr { call "lt" [$1,$3] }+ | expr 'le' expr { call "le" [$1,$3] }+ | expr 'gt' expr { call "gt" [$1,$3] }+ | expr 'ge' expr { call "ge" [$1,$3] } | expr 'and' expr { call "and" [$1,$3] } | expr 'or' expr { call "or" [$1,$3] } | expr 'not' expr { call "not" [$1,$3] } | expr 'union' expr { call "union" [$1,$3] }- | expr 'intersect' expr { call "itersect" [$1,$3] }+ | expr 'intersect' expr { call "intersect" [$1,$3] } | expr 'except' expr { call "except" [$1,$3] } | '+' expr %prec UMINUS { call "uplus" [$2] } | '-' expr %prec UMINUS { call "uminus" [$2] }@@ -158,11 +180,8 @@ | clauses 'let' let_bindings { $1 . $3 } for_bindings : var 'in' expr { \x -> Ast "for" [$1,Avar "$",$3,x] }- | var 'in' expr 'at' var { \x -> Ast "for" [$1,$5,$3,x] } | var 'at' var 'in' expr { \x -> Ast "for" [$1,$3,$5,x] } | for_bindings ',' var 'in' expr { \x -> $1(Ast "for" [$3,Avar "$",$5,x]) }- | for_bindings ',' var 'in' expr- 'at' var { \x -> $1(Ast "for" [$3,$7,$5,x]) } | for_bindings ',' var 'at' var 'in' expr { \x -> $1(Ast "for" [$3,$5,$7,x]) } @@ -194,15 +213,19 @@ then Ast "construction" ($1++[call "empty" []]) else error("Unmatched tags in element construction: "++$4) } | stag '/>' { Ast "construction" ($1++[call "empty" []]) }+ | 'element' '{' expr '}' '{' expl '}' { Ast "element_construction" [$3,concatenateAll $6] }+ | 'attribute' '{' expr '}''{' expl '}'{ Ast "attribute_construction" [$3,concatenateAll $6] }+ | 'element' 'QName' '{' expl '}' { Ast "element_construction" [Astring $2,concatenateAll $4] }+ | 'attribute' 'QName' '{' expl '}' { Ast "attribute_construction" [Astring $2,concatenateAll $4] } stag : '<' 'QName' { [Astring $2,Ast "attributes" []] } | '<' 'QName' attributes { [Astring $2,Ast "attributes" $3] } -content : '{' expl '}' { $2 }+content : '{' expl '}' { [concatenateAll $2] } | 'String' { [Astring $1] } | 'XMLtext' { [Astring $1] } | element { [$1] }- | content '{' expl '}' { $1++$3 }+ | content '{' expl '}' { $1++[concatenateAll $3] } | content 'String' { $1++[Astring $2] } | content 'XMLtext' { $1++[Astring $2] } | content element { $1++[$2] }@@ -213,40 +236,43 @@ | attributes 'QName' '=' '\'{' expr '}\'' { $1++[Ast "pair" [Astring $2,$5]] } -full_path : predicate_step { $1 "child" (Avar ".") }- | '@' predicate_step { $2 "child_attribute" (Avar ".") }- | predicate_step path { $2($1 "child" (Avar ".")) }- | '@' predicate_step path { $3($2 "child_attribute" (Avar ".")) }+full_path : predicate_step { Ast "step" ($1 "child_step" (Avar ".")) }+ | '@' predicate_step { Ast "step" ($2 "attribute_step" (Avar ".")) }+ | predicate_step path { Ast "step" [$2 (Ast "step" ($1 "child_step" (Avar ".")))] }+ | '@' predicate_step path { Ast "step" (map $3 ($2 "attribute_step" (Avar "."))) } -path : step { $1 }- | path step { $2 . $1 }+path : step { $1 }+ | path step { $2 . $1 } -step : '/' predicate_step { \e -> $2 "child" e }- | '/' '@' predicate_step { \e -> $3 "child_attribute" e }- | '/' '/' predicate_step { \e -> $3 "descendant" e }- | '/' '/' '@' predicate_step { \e -> $4 "descendant_attribute" e }- | '/' '..' { \e -> call "parent" [e] }+step : '/' predicate_step { \e -> Ast "step" ($2 "child_step" e) }+ | '/' '@' predicate_step { \e -> Ast "step" ($3 "attribute_step" e) }+ | '/' '/' predicate_step { \e -> Ast "step" ($3 "descendant_step" e) }+ | '/' '/' '@' predicate_step { \e -> Ast "step" ($4 "attribute_descendant_step" e) }+ | '/' '..' { \e -> Ast "step" [Ast "parent_step" [e]] } -predicate_step : simple_step { $1 }- | predicate_step '[' expr ']' { \t e -> Ast "predicate" [$3,$1 t e] }+predicate_step : simple_step { \t e -> [$1 t e] }+ | predicate_step '[' expr ']' { \t e -> ($1 t e)++[$3] } -simple_step : primary_expr { \t e -> $1 t e }- | '*' { \t e -> call t [Astring "*",e] }- | 'QName' { \t e -> call t [Astring $1,e] }+simple_step : primary_expr { \t e -> $1 t e }+ | '*' { \t e -> Ast t [Astring "*",e] }+ | 'QName' { \t e -> Ast t [Astring $1,e] } -primary_expr : var { \_ _ -> $1 }+primary_expr : var { \_ _ -> $1 } | '.' { \_ e -> e }- | '(' expl ')' { \_ _ -> concatAll $2 }- | '(' ')' { \_ _ -> call "empty" [] }- | 'QName' '(' expl ')' { \_ _ -> call $1 $3 }- | 'QName' '(' ')' { if elem $1 ["text"]+ | '(' expl ')' { \_ e -> if e == Avar "."+ then concatenateAll $2+ else Ast "context" [e,concatenateAll $2] }+ | '(' ')' { \_ _ -> call "empty" [] }+ | 'QName' '(' expl ')' { \_ e -> if e == Avar "."+ then call $1 $3+ else Ast "context" [e,call $1 $3] }+ | 'QName' '(' ')' { if elem $1 ["text"] then \_ e -> call $1 [e] else \_ _ -> call $1 [] } { - -- Abstract Syntax Tree for XQueries data Ast = Ast String [Ast] | Avar String@@ -271,8 +297,13 @@ call name args = Ast "call" ((Avar name):args) +concatenateAll :: [Ast] -> Ast+concatenateAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs+concatenateAll _ = call "empty" []++ concatAll :: [Ast] -> Ast-concatAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs+concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs concatAll _ = call "empty" [] @@ -282,10 +313,11 @@ 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 | ORDER | BY | ASCENDING- | DESCENDING | ELEMENT | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN- | SLASH | DEFINE | FUNCTION | AT | SEMI | DOT | DOTS | TokenEOF+ | TEQ | TNE | TLT | TLE | TGT | TGE | SEQ | SNE | SLT | SLE | SGT | SGE+ | AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA+ | ASSIGN | WHERE | ORDER | BY | ASCENDING | DESCENDING | ELEMENT+ | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN | SLASH | DECLARE | SEMI+ | FUNCTION | VARIABLE |AT | DOT | DOTS | TokenEOF | PRE | POST | IS | QName String | Variable String | XMLtext String | TInteger Int | TFloat Float | TString String deriving Show@@ -298,17 +330,26 @@ xmlText "" = [] xmlText text = [XMLtext text] --- scans XML PCDATA and returns an XMLtext token with the PCData text+-- scans XML syntax and returns an XMLtext token with the 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 n = xmlComment cs (text++"<!-") 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 ('\"':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)+xml ('(':':':cs) text n = xqComment cs text n xml (c:cs) text n = xml cs (text++[c]) n xml [] text _ = xmlText text +xqComment (':':')':cs) text n = xml cs text n+xqComment (_:cs) text n = xqComment cs text n+xqComment [] text _ = xmlText text +xmlComment ('-':'>':cs) text n = xml cs (text++"->") n+xmlComment (c:cs) text n = xmlComment cs (text++[c]) n+xmlComment [] text _ = xmlText text+ isQN c = elem c "_:-" || isDigit c || isAlpha c isVar c = elem c "_" || isDigit c || isAlpha c@@ -329,39 +370,49 @@ 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) n = TLE : lexer cs n+lexer ('>':'=':cs) n = TGE : lexer cs n+lexer ('<':'<':cs) n = PRE : lexer cs n+lexer ('>':'>':cs) n = POST : lexer cs n lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)+lexer ('(':':':cs) n = lexComment cs n+lexer ('<':'!':'-':cs) n = lexXmlComment cs "<!-" 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 = RESCAPE : lexer cs n-lexer ('!':'=':cs) n = TNEQ : lexer cs n+lexer ('!':'=':cs) n = TNE : lexer cs n lexer ('\'':cs) n = lexString cs n lexer ('\"':cs) n = lexString2 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] = RSB : lexer cs [n]+lexer ('}':cs) (_:n:ns) = RSB : (if n==0 then lexer cs (n:ns) else xml cs "" (n:ns)) 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) (k:n) = TGT : (if k==1 then lexer cs (0: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 = LSB : lexer cs (0:n)+lexer ('|':cs) n = UNION : 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 /= '.' then TInteger (read k) : lexer rest n else let (m,rest2) = span isDigit (tail rest)- in TFloat (read (k++('.':m))) : lexer rest2 n+ val::Float = read (k++('.':m))+ in case rest2 of+ ('e':rest3) -> let (exp,rest4) = span isDigit rest3+ in (TFloat (val*10^(read exp))) : lexer rest4 n+ _ -> (TFloat val) : lexer rest2 n where (k,rest) = span isDigit cs lexString cs n = TString s : lexer (tail rest) n@@ -372,6 +423,14 @@ where (s,rest) = span inString cs inString c = c /= '\"' +lexComment (':':')':cs) n = lexer cs n+lexComment (_:cs) n = lexComment cs n+lexComment [] n = []++lexXmlComment ('-':'>':cs) text n = (xmlText (text++"->"))++(lexer cs n)+lexXmlComment (c:cs) text n = lexXmlComment cs (text++[c]) n+lexXmlComment [] text _ = xmlText text+ lexVar cs n = case span isQN cs of ("return",rest) -> RETURN : lexer rest n@@ -401,8 +460,16 @@ ("element",rest) -> ELEMENT : lexer rest n ("attribute",rest) -> ATTRIBUTE : lexer rest n ("satisfies",rest) -> SATISFIES : lexer rest n- ("define",rest) -> DEFINE : lexer rest n+ ("declare",rest) -> DECLARE : lexer rest n ("function",rest) -> FUNCTION : lexer rest n+ ("variable",rest) -> VARIABLE : lexer rest n ("at",rest) -> AT : lexer rest n+ ("eq",rest) -> SEQ : lexer rest n+ ("ne",rest) -> SNE : lexer rest n+ ("lt",rest) -> SLT : lexer rest n+ ("le",rest) -> SLE : lexer rest n+ ("gt",rest) -> SGT : lexer rest n+ ("ge",rest) -> SGE : lexer rest n+ ("is",rest) -> IS : lexer rest n (var,rest) -> QName var : lexer rest n }
data/q1.xq view
@@ -1,8 +1,17 @@-define function f ( $x, $y ) = <student>{$x,' ',$y}</student>;+declare function fact ($n) { if $n=1 then 1 else $n*fact($n-1) }; +declare variable $x := fact(10);++declare function f ( $name, $gpa ) {+ <student>{ $name/firstname/text(),+ ' ',$name/lastname/text(),+ ': ',$gpa+ }</student>+};+ <students>{ for $s in doc('data/cs.xml')//gradstudent order by $s/gpa descending, $s//lastname- return f( $s/name, $s/gpa/text() )+ return f( $s/name, $s/gpa/text() ),+ $x }</students>-
index.html view
@@ -7,29 +7,29 @@ <p> <h2>Description</h2> <p>-HXQ is a fast and space-efficient translator from XQuery to-embedded Haskell code (the translation is based on GHC templates).-It takes full advantage-of Haskell's lazy evaluation to keep in memory only those parts of XML data-needed at each point of evaluation, thus performing stream-based evaluation.-This results to an implementation that is as fast and space-efficient as-any stream-based-implementation based on SAX filters or finite state machines. Furthermore,-the coding is far simpler and extensible since its based on XML trees, rather-than SAX events.-For example, the XQuery below against the <a href="http://dblp.uni-trier.de/xml/">DBLP XML database</a>-(420MB) runs in 1.5 minutes on my laptop.-My high-performance Java implementation of XQuery, called <a href="/XQPull/">XQPull</a>,-which is stream-based (based on a StAX events), took about the same time.+HXQ is a fast and space-efficient translator from XQuery (the standard+query language for XML) to embedded Haskell code. The translation is+based on Haskell templates. HXQ takes full advantage of Haskell's lazy+evaluation to keep in memory only those parts of XML data needed at+each point of evaluation, thus performing stream-based evaluation for+forward queries (queries that do not contain backward steps). This+results to an implementation that is as fast and space-efficient as+any stream-based implementation based on SAX filters or finite state+machines. Furthermore, the coding is far simpler and extensible since+its based on XML trees, rather than SAX events.++For example, the XQuery given at the bottom of this page, which is+against the <a href="http://dblp.uni-trier.de/xml/">DBLP XML+database</a> (420MB), runs in 39 seconds on my laptop. <p> HXQ uses the <a href="http://www.flightlab.com/~joe/hxml/">HXML parser for XML</a> (developed by Joe English), which is included in the source. I have also tried hexpat, but I found it too slow for large documents.-I haven't tried HaXML.+I haven't tried HaXML yet. <p> <h2>Installation Instructions</h2> <p>-If you haven't done so, install the Glasgow Haskell Compiler,+First, you need to install the Glasgow Haskell Compiler, <a href="http://www.haskell.org/ghc/">ghc</a>, and the parser generator for Haskell, <a href="http://www.haskell.org/happy/">happy</a>.@@ -37,42 +37,29 @@ <pre> yum install ghc happy </pre>-Then download <a href="/HXQ-0.5.tar.gz">HXQ</a> and untar it.+Then download <a href="/HXQ-0.6.tar.gz">HXQ</a> and untar it. You can either use cabal or make to build it. Then run xquery to test drive it. <p> <h2>Current Status</h2> <p> HXQ supports most essential XQuery features, although some system functions are missing (but are easy to add).-It does not have static typechecking; it leaves all checking to Haskell. This means that it distinguishes regular predicates-from indexing at run time: if an XPath predicate returns an integer at run time, it is indexing and this index is+To see the list of supported system functions, run <tt>xquery -help</tt> .+HXQ does not have static typechecking; it leaves all checking to Haskell. This means that it distinguishes regular predicates+from indexing at run time: if an XPath predicate returns an integer at run time, it is taken as indexing and this index is 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.+Some, but not all, parent axis steps are removed using optimization rules; all others cause a compilation error. <p> <h2>Using the Compiler</h2> <p>-HXQ represents XML data as rose trees:-<pre>-type Tag = String--type AttList = [(String,String)]--data XTree = XElem Tag AttList [XTree]- | XText String- | XInt Int- | XFloat Float--type XSeq = [XTree]-</pre>-which basically means that one cannot implement backward navigation steps directly. The main functions for embedding XQueries in Haskell are: <ul>-<li> <tt>$(xe query)</tt>-<li> <tt>$(xq query)</tt>+<li> <tt>$(xe query) :: XSeq</tt>+<li> <tt>$(xq query) :: IO XSeq</tt> </ul> where <tt>query</tt> is a string value (a Haskell expression that evaluates to a string <b>at compile-time</b>), They both translate the query into Haskell code, which is compiled and optimized into machine code directly.-The code that xe generates has type <tt>XSeq</tt> (a sequence of XML trees)+The code that xe generates has type <tt>XSeq</tt> (a sequence of XML trees of type <tt>[XTree]</tt>) while the code that xq generates has type <tt>(IO XSeq)</tt>. If the query reads at least one document (using doc(...)), then you should use xq since it requires IO. To define constant XML data or a function body, it is better to use xe.@@ -107,12 +94,15 @@ <li> <tt>xquery :: String -> IO XSeq</tt> -- Evaluates an XQuery in a string <li> <tt>xfile :: String -> IO XSeq</tt> -- Evaluates an XQuery in a file </ul>-The HXQ interpreter doesn't recognize Haskell variables and functions. The main HXQ program, called <tt>xquery</tt>,+The HXQ interpreter doesn't recognize Haskell variables and functions+(but you may declare XQuery variables and functions using the XQuery 'declare' syntax).+The main HXQ program, called <tt>xquery</tt>, evaluates an XQuery in a file using the interpreter. For example: <pre> xquery data/q1.xq </pre> Without an argument, it reads the XQuery from input.+With <tt>xquery -help</tt> you get the list of system functions. <p> <h2>Extending HXQ</h2> <p>@@ -124,4 +114,4 @@ <p> <hr> <p>-<address>Last modified: 03/23/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>+<address>Last modified: 03/30/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>