diff --git a/HXQ.cabal b/HXQ.cabal --- a/HXQ.cabal +++ b/HXQ.cabal @@ -1,5 +1,5 @@ Name: HXQ -Version: 0.4 +Version: 0.5 Description: A Compiler from XQuery to Haskell Synopsis: A Compiler from XQuery to Haskell Category: XML @@ -45,4 +45,3 @@ Executable: xquery Main-is: Main.hs ghc-options: -ihxml-0.2 - diff --git a/Main.hs b/Main.hs --- a/Main.hs +++ b/Main.hs @@ -17,7 +17,7 @@ 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) + 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 diff --git a/Makefile b/Makefile --- a/Makefile +++ b/Makefile @@ -21,6 +21,11 @@ ghci: XQueryParser.hs ghci -fth -i$(hxml) XQuery.hs XQueryCompiler.hs XQueryInterpreter.hs XQueryParser.hs +cabal: clean XQueryParser.hs + runhaskell Setup.lhs configure --prefix=$HOME + runhaskell Setup.lhs build + runhaskell Setup.lhs sdist + clean: /bin/rm -f *~ *.o *.hi $(hxml)/*.o $(hxml)/*.hi XQueryParser.hs *.stat *.prof *.ps *.aux *.hp xquery test1 test2 diff --git a/Test1.hs b/Test1.hs --- a/Test1.hs +++ b/Test1.hs @@ -16,7 +16,7 @@ f(d,s) = $(xe "{$s//firstname/text(),' ',$s//lastname/text()}") main = do a <- $(xq (" for $s in doc('data/cs.xml')//gradstudent " - ++" orderby $s/gpa descending, $s//lastname " + ++" order by $s/gpa descending, $s//lastname " ++" return {$s//firstname/text(),' ', " ++" $s//lastname/text(),' ', " ++" $s/gpa/text()} ")) diff --git a/Test2.hs b/Test2.hs --- a/Test2.hs +++ b/Test2.hs @@ -15,9 +15,9 @@ f(x,y) = $(xe "{$x,', ',$y}") main = do a <- $(xq ("{ " - ++" for $x in doc('/home/fegaras/data/dblp.xml')//inproceedings at $i " + ++" for $x at $i in doc('/home/fegaras/data/dblp.xml')//inproceedings " ++" where $x/author = 'Leonidas Fegaras' " - ++" orderby $x/year descending " + ++" order by $x/year descending " ++" return { $i, ') ', $x/booktitle/text(), " ++" ': ', $x/title/text() " ++" } " diff --git a/XQueryCompiler.hs b/XQueryCompiler.hs --- a/XQueryCompiler.hs +++ b/XQueryCompiler.hs @@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/ -- Creation: 02/15/08, last update: 03/23/08 +- Creation: 02/15/08, last update: 03/25/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. @@ -35,31 +35,32 @@ | XText String | XInt Int | XFloat Float - deriving Eq + deriving Eq type XSeq = [XTree] showAL :: AttList -> String -showAL = foldr(\(a,v) r -> " "++a++"=\'"++v++"\'"++r) [] +showAL = foldr(\(a,v) r -> " "++a++"=\""++v++"\""++r) [] -showXT :: XTree -> String -showXT (XElem tag al xs) = "<"++tag++(showAL al)++">"++(showXS xs)++"" -showXT (XText text) = text -showXT (XInt n) = " "++(show n) -showXT (XFloat n) = " "++(show n) +showXT :: XTree -> Bool -> String +showXT (XElem tag al xs) pad = "<"++tag++(showAL al)++">"++(showXS xs)++"" +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) showXS :: XSeq -> String -showXS xs = concat (map showXT xs) +showXS [] = "" +showXS (x:xs) = (showXT x False) ++ (concatMap (\x -> showXT x True) xs) instance Show XTree where - show t = showXT t + show t = showXT t False -- 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)))] + (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 @@ -86,8 +87,8 @@ -- XPath step //tag or //* descendant :: Tag -> XTree -> XSeq -descendant m (x@(XElem t al cs)) | m==t || m=="*" = x:(concat (map (descendant m) cs)) -descendant m (XElem t al cs) = concat (map (descendant m) cs) +descendant m (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 _ = [] @@ -106,7 +107,7 @@ = foldr (\(k,v) s -> if k==m || m=="*" then (XText v):s else s) - (concat (map (attributeDescendant m) cs)) al + (concatMap (attributeDescendant m) cs) al attributeDescendant m _ = [] @@ -220,7 +221,7 @@ ( "-", 2, \[xs,ys] -> [| [ arithmetic (-) x y | x <- toNum $xs, y <- toNum $ys ] |] ), ( "*", 2, \[xs,ys] -> [| [ arithmetic (*) x y | x <- toNum $xs, y <- toNum $ys ] |] ), ( "div", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ), - ( "idiv", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ), + ( "idiv", 2, \[xs,ys] -> [| [ XInt (div 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] |] ), @@ -235,11 +236,14 @@ ( "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 |] ), + ( "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 ] |] ), - ( "attribute", 2, \[tags,xs] -> [| [ z | (XText tag) <- $tags, x <- $xs, z <- attribute 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 |] ), @@ -247,11 +251,14 @@ case x of XElem t _ _ -> t==tag || tag=="*"; _ -> False ] |] ), ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute tag x ] |] ), ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ), - ( "concat", 2, \[xs,ys] -> [| $xs ++ $ys |] ), + ( "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 |] ), + ( "distinct-values", 1, \[xs] -> [| distinct $xs |] ), ( "union", 2, \[xs,ys] -> [| distinct ($xs ++ $ys) |] ), ( "intersect", 2, \[xs,ys] -> [| filter (\x -> elem x $ys) $xs |] ), - ( "except", 2, \[xs,ys] -> [| filter (\x -> not (elem x $ys)) $xs |] ) + ( "except", 2, \[xs,ys] -> [| filter (\x -> not (elem x $ys)) $xs |] ), + ( "reverse", 1, \[xs] -> [| reverse $xs |] ) ] @@ -397,7 +404,7 @@ Ast "pair" [Astring a,v] -> let ac = litE (StringL a) vc = compile v context index seqSize - in [| ($ac,showXS $vc) : $r |]) + in [| ($ac,showXS (text $vc)) : $r |]) [| [] |] al ct = litE (StringL tag) bc = compile body context index seqSize diff --git a/XQueryInterpreter.hs b/XQueryInterpreter.hs --- a/XQueryInterpreter.hs +++ b/XQueryInterpreter.hs @@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/ -- Creation: 03/22/08, last update: 03/23/08 +- Creation: 03/22/08, last update: 03/25/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. @@ -56,8 +56,8 @@ else error ("Wrong number of arguments in system call: "++fname) _ -> case filter (\(n,_,_) -> n==fname) fncs of [(_,params,body)] -> if (length params) == (length args) - then eval body ((map (\(p,a) -> (p,eval a env fncs)) - (zip params args))++env) fncs + 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] @@ -65,7 +65,7 @@ Ast "pair" [Astring a,Astring v] -> (a,v) Ast "pair" [Astring a,v] - -> (a,show (eval v env fncs))) al + -> (a,showXS (text (eval v env fncs)))) al in [ XElem tag alc (eval body env fncs) ] Ast "predicate" [condition,body] | containsLast condition -- blocking: use only when last() is used in condition diff --git a/XQueryParser.hs b/XQueryParser.hs --- a/XQueryParser.hs +++ b/XQueryParser.hs @@ -7,4229 +7,4389 @@ import GlaExts #endif --- 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 (56#) = happyShift action_20 -action_0 (60#) = happyShift action_21 -action_0 (61#) = happyShift action_22 -action_0 (69#) = happyShift action_23 -action_0 (70#) = happyShift action_24 -action_0 (74#) = happyShift action_25 -action_0 (76#) = happyShift action_26 -action_0 (77#) = happyShift action_34 -action_0 (81#) = happyShift action_27 -action_0 (83#) = happyShift action_28 -action_0 (85#) = happyShift action_29 -action_0 (86#) = happyShift action_30 -action_0 (87#) = happyShift action_31 -action_0 (4#) = happyGoto action_32 -action_0 (6#) = happyGoto action_2 -action_0 (7#) = happyGoto action_33 -action_0 (9#) = happyGoto action_4 -action_0 (16#) = happyGoto action_5 -action_0 (17#) = happyGoto action_6 -action_0 (18#) = happyGoto action_7 -action_0 (21#) = happyGoto action_8 -action_0 (24#) = happyGoto action_9 -action_0 (25#) = happyGoto action_10 -action_0 (26#) = happyGoto action_11 -action_0 x = happyTcHack x happyFail - -action_1 (28#) = happyShift action_12 -action_1 (29#) = happyShift action_13 -action_1 (30#) = happyShift action_14 -action_1 (35#) = happyShift action_15 -action_1 (42#) = happyShift action_16 -action_1 (43#) = happyShift action_17 -action_1 (44#) = happyShift action_18 -action_1 (50#) = happyShift action_19 -action_1 (56#) = happyShift action_20 -action_1 (60#) = happyShift action_21 -action_1 (61#) = happyShift action_22 -action_1 (69#) = happyShift action_23 -action_1 (70#) = happyShift action_24 -action_1 (74#) = happyShift action_25 -action_1 (76#) = happyShift action_26 -action_1 (81#) = happyShift action_27 -action_1 (83#) = happyShift action_28 -action_1 (85#) = happyShift action_29 -action_1 (86#) = happyShift action_30 -action_1 (87#) = happyShift action_31 -action_1 (6#) = happyGoto action_2 -action_1 (7#) = happyGoto action_3 -action_1 (9#) = happyGoto action_4 -action_1 (16#) = happyGoto action_5 -action_1 (17#) = happyGoto action_6 -action_1 (18#) = happyGoto action_7 -action_1 (21#) = happyGoto action_8 -action_1 (24#) = happyGoto action_9 -action_1 (25#) = happyGoto action_10 -action_1 (26#) = happyGoto action_11 -action_1 x = happyTcHack x happyFail - -action_2 x = happyTcHack x happyReduce_96 - -action_3 (41#) = happyShift action_36 -action_3 (42#) = happyShift action_37 -action_3 (43#) = happyShift action_38 -action_3 (44#) = happyShift action_39 -action_3 (45#) = happyShift action_40 -action_3 (46#) = happyShift action_41 -action_3 (47#) = happyShift action_42 -action_3 (48#) = happyShift action_43 -action_3 (49#) = happyShift action_44 -action_3 (50#) = happyShift action_45 -action_3 (51#) = happyShift action_46 -action_3 (52#) = happyShift action_47 -action_3 (53#) = happyShift action_48 -action_3 (54#) = happyShift action_49 -action_3 (55#) = happyShift action_50 -action_3 (56#) = happyShift action_51 -action_3 (57#) = happyShift action_52 -action_3 (58#) = happyShift action_53 -action_3 (59#) = happyShift action_54 -action_3 x = happyTcHack x happyFail - -action_4 (60#) = happyShift action_81 -action_4 (61#) = happyShift action_82 -action_4 (65#) = happyShift action_83 -action_4 (12#) = happyGoto action_80 -action_4 x = happyTcHack x happyReduce_53 - -action_5 x = happyTcHack x happyReduce_14 - -action_6 x = happyTcHack x happyReduce_13 - -action_7 (52#) = happyShift action_78 -action_7 (72#) = happyShift action_79 -action_7 x = happyTcHack x happyFail - -action_8 x = happyTcHack x happyReduce_12 - -action_9 (33#) = happyShift action_76 -action_9 (75#) = happyShift action_77 -action_9 (22#) = happyGoto action_74 -action_9 (23#) = happyGoto action_75 -action_9 x = happyTcHack x happyReduce_80 - -action_10 x = happyTcHack x happyReduce_91 - -action_11 x = happyTcHack x happyReduce_93 - -action_12 (83#) = happyShift action_28 -action_12 (6#) = happyGoto action_62 -action_12 (10#) = happyGoto action_73 -action_12 x = happyTcHack x happyFail - -action_13 (83#) = happyShift action_28 -action_13 (6#) = happyGoto action_62 -action_13 (10#) = happyGoto action_72 -action_13 x = happyTcHack x happyFail - -action_14 (28#) = happyShift action_12 -action_14 (29#) = happyShift action_13 -action_14 (30#) = happyShift action_14 -action_14 (35#) = happyShift action_15 -action_14 (42#) = happyShift action_16 -action_14 (43#) = happyShift action_17 -action_14 (44#) = happyShift action_18 -action_14 (50#) = happyShift action_19 -action_14 (56#) = happyShift action_20 -action_14 (60#) = happyShift action_21 -action_14 (61#) = happyShift action_22 -action_14 (69#) = happyShift action_23 -action_14 (70#) = happyShift action_24 -action_14 (74#) = happyShift action_25 -action_14 (76#) = happyShift action_26 -action_14 (81#) = happyShift action_27 -action_14 (83#) = happyShift action_28 -action_14 (85#) = happyShift action_29 -action_14 (86#) = happyShift action_30 -action_14 (87#) = happyShift action_31 -action_14 (6#) = happyGoto action_2 -action_14 (7#) = happyGoto action_71 -action_14 (9#) = happyGoto action_4 -action_14 (16#) = happyGoto action_5 -action_14 (17#) = happyGoto action_6 -action_14 (18#) = happyGoto action_7 -action_14 (21#) = happyGoto action_8 -action_14 (24#) = happyGoto action_9 -action_14 (25#) = happyGoto action_10 -action_14 (26#) = happyGoto action_11 -action_14 x = happyTcHack x happyFail - -action_15 (28#) = happyShift action_12 -action_15 (29#) = happyShift action_13 -action_15 (30#) = happyShift action_14 -action_15 (35#) = happyShift action_15 -action_15 (36#) = happyShift action_70 -action_15 (42#) = happyShift action_16 -action_15 (43#) = happyShift action_17 -action_15 (44#) = happyShift action_18 -action_15 (50#) = happyShift action_19 -action_15 (56#) = happyShift action_20 -action_15 (60#) = happyShift action_21 -action_15 (61#) = happyShift action_22 -action_15 (69#) = happyShift action_23 -action_15 (70#) = happyShift action_24 -action_15 (74#) = happyShift action_25 -action_15 (76#) = happyShift action_26 -action_15 (81#) = happyShift action_27 -action_15 (83#) = happyShift action_28 -action_15 (85#) = happyShift action_29 -action_15 (86#) = happyShift action_30 -action_15 (87#) = happyShift action_31 -action_15 (6#) = happyGoto action_2 -action_15 (7#) = happyGoto action_68 -action_15 (8#) = happyGoto action_69 -action_15 (9#) = happyGoto action_4 -action_15 (16#) = happyGoto action_5 -action_15 (17#) = happyGoto action_6 -action_15 (18#) = happyGoto action_7 -action_15 (21#) = happyGoto action_8 -action_15 (24#) = happyGoto action_9 -action_15 (25#) = happyGoto action_10 -action_15 (26#) = happyGoto action_11 -action_15 x = happyTcHack x happyFail - -action_16 (28#) = happyShift action_12 -action_16 (29#) = happyShift action_13 -action_16 (30#) = happyShift action_14 -action_16 (35#) = happyShift action_15 -action_16 (42#) = happyShift action_16 -action_16 (43#) = happyShift action_17 -action_16 (44#) = happyShift action_18 -action_16 (50#) = happyShift action_19 -action_16 (56#) = happyShift action_20 -action_16 (60#) = happyShift action_21 -action_16 (61#) = happyShift action_22 -action_16 (69#) = happyShift action_23 -action_16 (70#) = happyShift action_24 -action_16 (74#) = happyShift action_25 -action_16 (76#) = happyShift action_26 -action_16 (81#) = happyShift action_27 -action_16 (83#) = happyShift action_28 -action_16 (85#) = happyShift action_29 -action_16 (86#) = happyShift action_30 -action_16 (87#) = happyShift action_31 -action_16 (6#) = happyGoto action_2 -action_16 (7#) = happyGoto action_67 -action_16 (9#) = happyGoto action_4 -action_16 (16#) = happyGoto action_5 -action_16 (17#) = happyGoto action_6 -action_16 (18#) = happyGoto action_7 -action_16 (21#) = happyGoto action_8 -action_16 (24#) = happyGoto action_9 -action_16 (25#) = happyGoto action_10 -action_16 (26#) = happyGoto action_11 -action_16 x = happyTcHack x happyFail - -action_17 (28#) = happyShift action_12 -action_17 (29#) = happyShift action_13 -action_17 (30#) = happyShift action_14 -action_17 (35#) = happyShift action_15 -action_17 (42#) = happyShift action_16 -action_17 (43#) = happyShift action_17 -action_17 (44#) = happyShift action_18 -action_17 (50#) = happyShift action_19 -action_17 (56#) = happyShift action_20 -action_17 (60#) = happyShift action_21 -action_17 (61#) = happyShift action_22 -action_17 (69#) = happyShift action_23 -action_17 (70#) = happyShift action_24 -action_17 (74#) = happyShift action_25 -action_17 (76#) = happyShift action_26 -action_17 (81#) = happyShift action_27 -action_17 (83#) = happyShift action_28 -action_17 (85#) = happyShift action_29 -action_17 (86#) = happyShift action_30 -action_17 (87#) = happyShift action_31 -action_17 (6#) = happyGoto action_2 -action_17 (7#) = happyGoto action_66 -action_17 (9#) = happyGoto action_4 -action_17 (16#) = happyGoto action_5 -action_17 (17#) = happyGoto action_6 -action_17 (18#) = happyGoto action_7 -action_17 (21#) = happyGoto action_8 -action_17 (24#) = happyGoto action_9 -action_17 (25#) = happyGoto action_10 -action_17 (26#) = happyGoto action_11 -action_17 x = happyTcHack x happyFail - -action_18 x = happyTcHack x happyReduce_94 - -action_19 (76#) = happyShift action_65 -action_19 x = happyTcHack x happyFail - -action_20 (28#) = happyShift action_12 -action_20 (29#) = happyShift action_13 -action_20 (30#) = happyShift action_14 -action_20 (35#) = happyShift action_15 -action_20 (42#) = happyShift action_16 -action_20 (43#) = happyShift action_17 -action_20 (44#) = happyShift action_18 -action_20 (50#) = happyShift action_19 -action_20 (56#) = happyShift action_20 -action_20 (60#) = happyShift action_21 -action_20 (61#) = happyShift action_22 -action_20 (69#) = happyShift action_23 -action_20 (70#) = happyShift action_24 -action_20 (74#) = happyShift action_25 -action_20 (76#) = happyShift action_26 -action_20 (81#) = happyShift action_27 -action_20 (83#) = happyShift action_28 -action_20 (85#) = happyShift action_29 -action_20 (86#) = happyShift action_30 -action_20 (87#) = happyShift action_31 -action_20 (6#) = happyGoto action_2 -action_20 (7#) = happyGoto action_64 -action_20 (9#) = happyGoto action_4 -action_20 (16#) = happyGoto action_5 -action_20 (17#) = happyGoto action_6 -action_20 (18#) = happyGoto action_7 -action_20 (21#) = happyGoto action_8 -action_20 (24#) = happyGoto action_9 -action_20 (25#) = happyGoto action_10 -action_20 (26#) = happyGoto action_11 -action_20 x = happyTcHack x happyFail - -action_21 (83#) = happyShift action_28 -action_21 (6#) = happyGoto action_62 -action_21 (10#) = happyGoto action_63 -action_21 x = happyTcHack x happyFail - -action_22 (83#) = happyShift action_28 -action_22 (6#) = happyGoto action_60 -action_22 (11#) = happyGoto action_61 -action_22 x = happyTcHack x happyFail - -action_23 (35#) = happyShift action_59 -action_23 x = happyTcHack x happyFail - -action_24 (35#) = happyShift action_58 -action_24 x = happyTcHack x happyFail - -action_25 (35#) = happyShift action_15 -action_25 (44#) = happyShift action_18 -action_25 (76#) = happyShift action_26 -action_25 (81#) = happyShift action_27 -action_25 (83#) = happyShift action_28 -action_25 (6#) = happyGoto action_2 -action_25 (24#) = happyGoto action_57 -action_25 (25#) = happyGoto action_10 -action_25 (26#) = happyGoto action_11 -action_25 x = happyTcHack x happyFail - -action_26 (35#) = happyShift action_56 -action_26 x = happyTcHack x happyReduce_95 - -action_27 x = happyTcHack x happyReduce_97 - -action_28 x = happyTcHack x happyReduce_7 - -action_29 x = happyTcHack x happyReduce_38 - -action_30 x = happyTcHack x happyReduce_39 - -action_31 x = happyTcHack x happyReduce_37 - -action_32 (88#) = happyAccept -action_32 x = happyTcHack x happyFail - -action_33 (41#) = happyShift action_36 -action_33 (42#) = happyShift action_37 -action_33 (43#) = happyShift action_38 -action_33 (44#) = happyShift action_39 -action_33 (45#) = happyShift action_40 -action_33 (46#) = happyShift action_41 -action_33 (47#) = happyShift action_42 -action_33 (48#) = happyShift action_43 -action_33 (49#) = happyShift action_44 -action_33 (50#) = happyShift action_45 -action_33 (51#) = happyShift action_46 -action_33 (52#) = happyShift action_47 -action_33 (53#) = happyShift action_48 -action_33 (54#) = happyShift action_49 -action_33 (55#) = happyShift action_50 -action_33 (56#) = happyShift action_51 -action_33 (57#) = happyShift action_52 -action_33 (58#) = happyShift action_53 -action_33 (59#) = happyShift action_54 -action_33 (84#) = happyShift action_55 -action_33 x = happyTcHack x happyReduce_1 - -action_34 (78#) = happyShift action_35 -action_34 x = happyTcHack x happyFail - -action_35 (76#) = happyShift action_136 -action_35 x = happyTcHack x happyFail - -action_36 (28#) = happyShift action_12 -action_36 (29#) = happyShift action_13 -action_36 (30#) = happyShift action_14 -action_36 (35#) = happyShift action_15 -action_36 (42#) = happyShift action_16 -action_36 (43#) = happyShift action_17 -action_36 (44#) = happyShift action_18 -action_36 (50#) = happyShift action_19 -action_36 (56#) = happyShift action_20 -action_36 (60#) = happyShift action_21 -action_36 (61#) = happyShift action_22 -action_36 (69#) = happyShift action_23 -action_36 (70#) = happyShift action_24 -action_36 (74#) = happyShift action_25 -action_36 (76#) = happyShift action_26 -action_36 (81#) = happyShift action_27 -action_36 (83#) = happyShift action_28 -action_36 (85#) = happyShift action_29 -action_36 (86#) = happyShift action_30 -action_36 (87#) = happyShift action_31 -action_36 (6#) = happyGoto action_2 -action_36 (7#) = happyGoto action_135 -action_36 (9#) = happyGoto action_4 -action_36 (16#) = happyGoto action_5 -action_36 (17#) = happyGoto action_6 -action_36 (18#) = happyGoto action_7 -action_36 (21#) = happyGoto action_8 -action_36 (24#) = happyGoto action_9 -action_36 (25#) = happyGoto action_10 -action_36 (26#) = happyGoto action_11 -action_36 x = happyTcHack x happyFail - -action_37 (28#) = happyShift action_12 -action_37 (29#) = happyShift action_13 -action_37 (30#) = happyShift action_14 -action_37 (35#) = happyShift action_15 -action_37 (42#) = happyShift action_16 -action_37 (43#) = happyShift action_17 -action_37 (44#) = happyShift action_18 -action_37 (50#) = happyShift action_19 -action_37 (56#) = happyShift action_20 -action_37 (60#) = happyShift action_21 -action_37 (61#) = happyShift action_22 -action_37 (69#) = happyShift action_23 -action_37 (70#) = happyShift action_24 -action_37 (74#) = happyShift action_25 -action_37 (76#) = happyShift action_26 -action_37 (81#) = happyShift action_27 -action_37 (83#) = happyShift action_28 -action_37 (85#) = happyShift action_29 -action_37 (86#) = happyShift action_30 -action_37 (87#) = happyShift action_31 -action_37 (6#) = happyGoto action_2 -action_37 (7#) = happyGoto action_134 -action_37 (9#) = happyGoto action_4 -action_37 (16#) = happyGoto action_5 -action_37 (17#) = happyGoto action_6 -action_37 (18#) = happyGoto action_7 -action_37 (21#) = happyGoto action_8 -action_37 (24#) = happyGoto action_9 -action_37 (25#) = happyGoto action_10 -action_37 (26#) = happyGoto action_11 -action_37 x = happyTcHack x happyFail - -action_38 (28#) = happyShift action_12 -action_38 (29#) = happyShift action_13 -action_38 (30#) = happyShift action_14 -action_38 (35#) = happyShift action_15 -action_38 (42#) = happyShift action_16 -action_38 (43#) = happyShift action_17 -action_38 (44#) = happyShift action_18 -action_38 (50#) = happyShift action_19 -action_38 (56#) = happyShift action_20 -action_38 (60#) = happyShift action_21 -action_38 (61#) = happyShift action_22 -action_38 (69#) = happyShift action_23 -action_38 (70#) = happyShift action_24 -action_38 (74#) = happyShift action_25 -action_38 (76#) = happyShift action_26 -action_38 (81#) = happyShift action_27 -action_38 (83#) = happyShift action_28 -action_38 (85#) = happyShift action_29 -action_38 (86#) = happyShift action_30 -action_38 (87#) = happyShift action_31 -action_38 (6#) = happyGoto action_2 -action_38 (7#) = happyGoto action_133 -action_38 (9#) = happyGoto action_4 -action_38 (16#) = happyGoto action_5 -action_38 (17#) = happyGoto action_6 -action_38 (18#) = happyGoto action_7 -action_38 (21#) = happyGoto action_8 -action_38 (24#) = happyGoto action_9 -action_38 (25#) = happyGoto action_10 -action_38 (26#) = happyGoto action_11 -action_38 x = happyTcHack x happyFail - -action_39 (28#) = happyShift action_12 -action_39 (29#) = happyShift action_13 -action_39 (30#) = happyShift action_14 -action_39 (35#) = happyShift action_15 -action_39 (42#) = happyShift action_16 -action_39 (43#) = happyShift action_17 -action_39 (44#) = happyShift action_18 -action_39 (50#) = happyShift action_19 -action_39 (56#) = happyShift action_20 -action_39 (60#) = happyShift action_21 -action_39 (61#) = happyShift action_22 -action_39 (69#) = happyShift action_23 -action_39 (70#) = happyShift action_24 -action_39 (74#) = happyShift action_25 -action_39 (76#) = happyShift action_26 -action_39 (81#) = happyShift action_27 -action_39 (83#) = happyShift action_28 -action_39 (85#) = happyShift action_29 -action_39 (86#) = happyShift action_30 -action_39 (87#) = happyShift action_31 -action_39 (6#) = happyGoto action_2 -action_39 (7#) = happyGoto action_132 -action_39 (9#) = happyGoto action_4 -action_39 (16#) = happyGoto action_5 -action_39 (17#) = happyGoto action_6 -action_39 (18#) = happyGoto action_7 -action_39 (21#) = happyGoto action_8 -action_39 (24#) = happyGoto action_9 -action_39 (25#) = happyGoto action_10 -action_39 (26#) = happyGoto action_11 -action_39 x = happyTcHack x happyFail - -action_40 (28#) = happyShift action_12 -action_40 (29#) = happyShift action_13 -action_40 (30#) = happyShift action_14 -action_40 (35#) = happyShift action_15 -action_40 (42#) = happyShift action_16 -action_40 (43#) = happyShift action_17 -action_40 (44#) = happyShift action_18 -action_40 (50#) = happyShift action_19 -action_40 (56#) = happyShift action_20 -action_40 (60#) = happyShift action_21 -action_40 (61#) = happyShift action_22 -action_40 (69#) = happyShift action_23 -action_40 (70#) = happyShift action_24 -action_40 (74#) = happyShift action_25 -action_40 (76#) = happyShift action_26 -action_40 (81#) = happyShift action_27 -action_40 (83#) = happyShift action_28 -action_40 (85#) = happyShift action_29 -action_40 (86#) = happyShift action_30 -action_40 (87#) = happyShift action_31 -action_40 (6#) = happyGoto action_2 -action_40 (7#) = happyGoto action_131 -action_40 (9#) = happyGoto action_4 -action_40 (16#) = happyGoto action_5 -action_40 (17#) = happyGoto action_6 -action_40 (18#) = happyGoto action_7 -action_40 (21#) = happyGoto action_8 -action_40 (24#) = happyGoto action_9 -action_40 (25#) = happyGoto action_10 -action_40 (26#) = happyGoto action_11 -action_40 x = happyTcHack x happyFail - -action_41 (28#) = happyShift action_12 -action_41 (29#) = happyShift action_13 -action_41 (30#) = happyShift action_14 -action_41 (35#) = happyShift action_15 -action_41 (42#) = happyShift action_16 -action_41 (43#) = happyShift action_17 -action_41 (44#) = happyShift action_18 -action_41 (50#) = happyShift action_19 -action_41 (56#) = happyShift action_20 -action_41 (60#) = happyShift action_21 -action_41 (61#) = happyShift action_22 -action_41 (69#) = happyShift action_23 -action_41 (70#) = happyShift action_24 -action_41 (74#) = happyShift action_25 -action_41 (76#) = happyShift action_26 -action_41 (81#) = happyShift action_27 -action_41 (83#) = happyShift action_28 -action_41 (85#) = happyShift action_29 -action_41 (86#) = happyShift action_30 -action_41 (87#) = happyShift action_31 -action_41 (6#) = happyGoto action_2 -action_41 (7#) = happyGoto action_130 -action_41 (9#) = happyGoto action_4 -action_41 (16#) = happyGoto action_5 -action_41 (17#) = happyGoto action_6 -action_41 (18#) = happyGoto action_7 -action_41 (21#) = happyGoto action_8 -action_41 (24#) = happyGoto action_9 -action_41 (25#) = happyGoto action_10 -action_41 (26#) = happyGoto action_11 -action_41 x = happyTcHack x happyFail - -action_42 (28#) = happyShift action_12 -action_42 (29#) = happyShift action_13 -action_42 (30#) = happyShift action_14 -action_42 (35#) = happyShift action_15 -action_42 (42#) = happyShift action_16 -action_42 (43#) = happyShift action_17 -action_42 (44#) = happyShift action_18 -action_42 (50#) = happyShift action_19 -action_42 (56#) = happyShift action_20 -action_42 (60#) = happyShift action_21 -action_42 (61#) = happyShift action_22 -action_42 (69#) = happyShift action_23 -action_42 (70#) = happyShift action_24 -action_42 (74#) = happyShift action_25 -action_42 (76#) = happyShift action_26 -action_42 (81#) = happyShift action_27 -action_42 (83#) = happyShift action_28 -action_42 (85#) = happyShift action_29 -action_42 (86#) = happyShift action_30 -action_42 (87#) = happyShift action_31 -action_42 (6#) = happyGoto action_2 -action_42 (7#) = happyGoto action_129 -action_42 (9#) = happyGoto action_4 -action_42 (16#) = happyGoto action_5 -action_42 (17#) = happyGoto action_6 -action_42 (18#) = happyGoto action_7 -action_42 (21#) = happyGoto action_8 -action_42 (24#) = happyGoto action_9 -action_42 (25#) = happyGoto action_10 -action_42 (26#) = happyGoto action_11 -action_42 x = happyTcHack x happyFail - -action_43 (28#) = happyShift action_12 -action_43 (29#) = happyShift action_13 -action_43 (30#) = happyShift action_14 -action_43 (35#) = happyShift action_15 -action_43 (42#) = happyShift action_16 -action_43 (43#) = happyShift action_17 -action_43 (44#) = happyShift action_18 -action_43 (50#) = happyShift action_19 -action_43 (56#) = happyShift action_20 -action_43 (60#) = happyShift action_21 -action_43 (61#) = happyShift action_22 -action_43 (69#) = happyShift action_23 -action_43 (70#) = happyShift action_24 -action_43 (74#) = happyShift action_25 -action_43 (76#) = happyShift action_26 -action_43 (81#) = happyShift action_27 -action_43 (83#) = happyShift action_28 -action_43 (85#) = happyShift action_29 -action_43 (86#) = happyShift action_30 -action_43 (87#) = happyShift action_31 -action_43 (6#) = happyGoto action_2 -action_43 (7#) = happyGoto action_128 -action_43 (9#) = happyGoto action_4 -action_43 (16#) = happyGoto action_5 -action_43 (17#) = happyGoto action_6 -action_43 (18#) = happyGoto action_7 -action_43 (21#) = happyGoto action_8 -action_43 (24#) = happyGoto action_9 -action_43 (25#) = happyGoto action_10 -action_43 (26#) = happyGoto action_11 -action_43 x = happyTcHack x happyFail - -action_44 (28#) = happyShift action_12 -action_44 (29#) = happyShift action_13 -action_44 (30#) = happyShift action_14 -action_44 (35#) = happyShift action_15 -action_44 (42#) = happyShift action_16 -action_44 (43#) = happyShift action_17 -action_44 (44#) = happyShift action_18 -action_44 (50#) = happyShift action_19 -action_44 (56#) = happyShift action_20 -action_44 (60#) = happyShift action_21 -action_44 (61#) = happyShift action_22 -action_44 (69#) = happyShift action_23 -action_44 (70#) = happyShift action_24 -action_44 (74#) = happyShift action_25 -action_44 (76#) = happyShift action_26 -action_44 (81#) = happyShift action_27 -action_44 (83#) = happyShift action_28 -action_44 (85#) = happyShift action_29 -action_44 (86#) = happyShift action_30 -action_44 (87#) = happyShift action_31 -action_44 (6#) = happyGoto action_2 -action_44 (7#) = happyGoto action_127 -action_44 (9#) = happyGoto action_4 -action_44 (16#) = happyGoto action_5 -action_44 (17#) = happyGoto action_6 -action_44 (18#) = happyGoto action_7 -action_44 (21#) = happyGoto action_8 -action_44 (24#) = happyGoto action_9 -action_44 (25#) = happyGoto action_10 -action_44 (26#) = happyGoto action_11 -action_44 x = happyTcHack x happyFail - -action_45 (28#) = happyShift action_12 -action_45 (29#) = happyShift action_13 -action_45 (30#) = happyShift action_14 -action_45 (35#) = happyShift action_15 -action_45 (42#) = happyShift action_16 -action_45 (43#) = happyShift action_17 -action_45 (44#) = happyShift action_18 -action_45 (50#) = happyShift action_19 -action_45 (56#) = happyShift action_20 -action_45 (60#) = happyShift action_21 -action_45 (61#) = happyShift action_22 -action_45 (69#) = happyShift action_23 -action_45 (70#) = happyShift action_24 -action_45 (74#) = happyShift action_25 -action_45 (76#) = happyShift action_26 -action_45 (81#) = happyShift action_27 -action_45 (83#) = happyShift action_28 -action_45 (85#) = happyShift action_29 -action_45 (86#) = happyShift action_30 -action_45 (87#) = happyShift action_31 -action_45 (6#) = happyGoto action_2 -action_45 (7#) = happyGoto action_126 -action_45 (9#) = happyGoto action_4 -action_45 (16#) = happyGoto action_5 -action_45 (17#) = happyGoto action_6 -action_45 (18#) = happyGoto action_7 -action_45 (21#) = happyGoto action_8 -action_45 (24#) = happyGoto action_9 -action_45 (25#) = happyGoto action_10 -action_45 (26#) = happyGoto action_11 -action_45 x = happyTcHack x happyFail - -action_46 (28#) = happyShift action_12 -action_46 (29#) = happyShift action_13 -action_46 (30#) = happyShift action_14 -action_46 (35#) = happyShift action_15 -action_46 (42#) = happyShift action_16 -action_46 (43#) = happyShift action_17 -action_46 (44#) = happyShift action_18 -action_46 (50#) = happyShift action_19 -action_46 (56#) = happyShift action_20 -action_46 (60#) = happyShift action_21 -action_46 (61#) = happyShift action_22 -action_46 (69#) = happyShift action_23 -action_46 (70#) = happyShift action_24 -action_46 (74#) = happyShift action_25 -action_46 (76#) = happyShift action_26 -action_46 (81#) = happyShift action_27 -action_46 (83#) = happyShift action_28 -action_46 (85#) = happyShift action_29 -action_46 (86#) = happyShift action_30 -action_46 (87#) = happyShift action_31 -action_46 (6#) = happyGoto action_2 -action_46 (7#) = happyGoto action_125 -action_46 (9#) = happyGoto action_4 -action_46 (16#) = happyGoto action_5 -action_46 (17#) = happyGoto action_6 -action_46 (18#) = happyGoto action_7 -action_46 (21#) = happyGoto action_8 -action_46 (24#) = happyGoto action_9 -action_46 (25#) = happyGoto action_10 -action_46 (26#) = happyGoto action_11 -action_46 x = happyTcHack x happyFail - -action_47 (28#) = happyShift action_12 -action_47 (29#) = happyShift action_13 -action_47 (30#) = happyShift action_14 -action_47 (35#) = happyShift action_15 -action_47 (42#) = happyShift action_16 -action_47 (43#) = happyShift action_17 -action_47 (44#) = happyShift action_18 -action_47 (50#) = happyShift action_19 -action_47 (56#) = happyShift action_20 -action_47 (60#) = happyShift action_21 -action_47 (61#) = happyShift action_22 -action_47 (69#) = happyShift action_23 -action_47 (70#) = happyShift action_24 -action_47 (74#) = happyShift action_25 -action_47 (76#) = happyShift action_26 -action_47 (81#) = happyShift action_27 -action_47 (83#) = happyShift action_28 -action_47 (85#) = happyShift action_29 -action_47 (86#) = happyShift action_30 -action_47 (87#) = happyShift action_31 -action_47 (6#) = happyGoto action_2 -action_47 (7#) = happyGoto action_124 -action_47 (9#) = happyGoto action_4 -action_47 (16#) = happyGoto action_5 -action_47 (17#) = happyGoto action_6 -action_47 (18#) = happyGoto action_7 -action_47 (21#) = happyGoto action_8 -action_47 (24#) = happyGoto action_9 -action_47 (25#) = happyGoto action_10 -action_47 (26#) = happyGoto action_11 -action_47 x = happyTcHack x happyFail - -action_48 (28#) = happyShift action_12 -action_48 (29#) = happyShift action_13 -action_48 (30#) = happyShift action_14 -action_48 (35#) = happyShift action_15 -action_48 (42#) = happyShift action_16 -action_48 (43#) = happyShift action_17 -action_48 (44#) = happyShift action_18 -action_48 (50#) = happyShift action_19 -action_48 (56#) = happyShift action_20 -action_48 (60#) = happyShift action_21 -action_48 (61#) = happyShift action_22 -action_48 (69#) = happyShift action_23 -action_48 (70#) = happyShift action_24 -action_48 (74#) = happyShift action_25 -action_48 (76#) = happyShift action_26 -action_48 (81#) = happyShift action_27 -action_48 (83#) = happyShift action_28 -action_48 (85#) = happyShift action_29 -action_48 (86#) = happyShift action_30 -action_48 (87#) = happyShift action_31 -action_48 (6#) = happyGoto action_2 -action_48 (7#) = happyGoto action_123 -action_48 (9#) = happyGoto action_4 -action_48 (16#) = happyGoto action_5 -action_48 (17#) = happyGoto action_6 -action_48 (18#) = happyGoto action_7 -action_48 (21#) = happyGoto action_8 -action_48 (24#) = happyGoto action_9 -action_48 (25#) = happyGoto action_10 -action_48 (26#) = happyGoto action_11 -action_48 x = happyTcHack x happyFail - -action_49 (28#) = happyShift action_12 -action_49 (29#) = happyShift action_13 -action_49 (30#) = happyShift action_14 -action_49 (35#) = happyShift action_15 -action_49 (42#) = happyShift action_16 -action_49 (43#) = happyShift action_17 -action_49 (44#) = happyShift action_18 -action_49 (50#) = happyShift action_19 -action_49 (56#) = happyShift action_20 -action_49 (60#) = happyShift action_21 -action_49 (61#) = happyShift action_22 -action_49 (69#) = happyShift action_23 -action_49 (70#) = happyShift action_24 -action_49 (74#) = happyShift action_25 -action_49 (76#) = happyShift action_26 -action_49 (81#) = happyShift action_27 -action_49 (83#) = happyShift action_28 -action_49 (85#) = happyShift action_29 -action_49 (86#) = happyShift action_30 -action_49 (87#) = happyShift action_31 -action_49 (6#) = happyGoto action_2 -action_49 (7#) = happyGoto action_122 -action_49 (9#) = happyGoto action_4 -action_49 (16#) = happyGoto action_5 -action_49 (17#) = happyGoto action_6 -action_49 (18#) = happyGoto action_7 -action_49 (21#) = happyGoto action_8 -action_49 (24#) = happyGoto action_9 -action_49 (25#) = happyGoto action_10 -action_49 (26#) = happyGoto action_11 -action_49 x = happyTcHack x happyFail - -action_50 (28#) = happyShift action_12 -action_50 (29#) = happyShift action_13 -action_50 (30#) = happyShift action_14 -action_50 (35#) = happyShift action_15 -action_50 (42#) = happyShift action_16 -action_50 (43#) = happyShift action_17 -action_50 (44#) = happyShift action_18 -action_50 (50#) = happyShift action_19 -action_50 (56#) = happyShift action_20 -action_50 (60#) = happyShift action_21 -action_50 (61#) = happyShift action_22 -action_50 (69#) = happyShift action_23 -action_50 (70#) = happyShift action_24 -action_50 (74#) = happyShift action_25 -action_50 (76#) = happyShift action_26 -action_50 (81#) = happyShift action_27 -action_50 (83#) = happyShift action_28 -action_50 (85#) = happyShift action_29 -action_50 (86#) = happyShift action_30 -action_50 (87#) = happyShift action_31 -action_50 (6#) = happyGoto action_2 -action_50 (7#) = happyGoto action_121 -action_50 (9#) = happyGoto action_4 -action_50 (16#) = happyGoto action_5 -action_50 (17#) = happyGoto action_6 -action_50 (18#) = happyGoto action_7 -action_50 (21#) = happyGoto action_8 -action_50 (24#) = happyGoto action_9 -action_50 (25#) = happyGoto action_10 -action_50 (26#) = happyGoto action_11 -action_50 x = happyTcHack x happyFail - -action_51 (28#) = happyShift action_12 -action_51 (29#) = happyShift action_13 -action_51 (30#) = happyShift action_14 -action_51 (35#) = happyShift action_15 -action_51 (42#) = happyShift action_16 -action_51 (43#) = happyShift action_17 -action_51 (44#) = happyShift action_18 -action_51 (50#) = happyShift action_19 -action_51 (56#) = happyShift action_20 -action_51 (60#) = happyShift action_21 -action_51 (61#) = happyShift action_22 -action_51 (69#) = happyShift action_23 -action_51 (70#) = happyShift action_24 -action_51 (74#) = happyShift action_25 -action_51 (76#) = happyShift action_26 -action_51 (81#) = happyShift action_27 -action_51 (83#) = happyShift action_28 -action_51 (85#) = happyShift action_29 -action_51 (86#) = happyShift action_30 -action_51 (87#) = happyShift action_31 -action_51 (6#) = happyGoto action_2 -action_51 (7#) = happyGoto action_120 -action_51 (9#) = happyGoto action_4 -action_51 (16#) = happyGoto action_5 -action_51 (17#) = happyGoto action_6 -action_51 (18#) = happyGoto action_7 -action_51 (21#) = happyGoto action_8 -action_51 (24#) = happyGoto action_9 -action_51 (25#) = happyGoto action_10 -action_51 (26#) = happyGoto action_11 -action_51 x = happyTcHack x happyFail - -action_52 (28#) = happyShift action_12 -action_52 (29#) = happyShift action_13 -action_52 (30#) = happyShift action_14 -action_52 (35#) = happyShift action_15 -action_52 (42#) = happyShift action_16 -action_52 (43#) = happyShift action_17 -action_52 (44#) = happyShift action_18 -action_52 (50#) = happyShift action_19 -action_52 (56#) = happyShift action_20 -action_52 (60#) = happyShift action_21 -action_52 (61#) = happyShift action_22 -action_52 (69#) = happyShift action_23 -action_52 (70#) = happyShift action_24 -action_52 (74#) = happyShift action_25 -action_52 (76#) = happyShift action_26 -action_52 (81#) = happyShift action_27 -action_52 (83#) = happyShift action_28 -action_52 (85#) = happyShift action_29 -action_52 (86#) = happyShift action_30 -action_52 (87#) = happyShift action_31 -action_52 (6#) = happyGoto action_2 -action_52 (7#) = happyGoto action_119 -action_52 (9#) = happyGoto action_4 -action_52 (16#) = happyGoto action_5 -action_52 (17#) = happyGoto action_6 -action_52 (18#) = happyGoto action_7 -action_52 (21#) = happyGoto action_8 -action_52 (24#) = happyGoto action_9 -action_52 (25#) = happyGoto action_10 -action_52 (26#) = happyGoto action_11 -action_52 x = happyTcHack x happyFail - -action_53 (28#) = happyShift action_12 -action_53 (29#) = happyShift action_13 -action_53 (30#) = happyShift action_14 -action_53 (35#) = happyShift action_15 -action_53 (42#) = happyShift action_16 -action_53 (43#) = happyShift action_17 -action_53 (44#) = happyShift action_18 -action_53 (50#) = happyShift action_19 -action_53 (56#) = happyShift action_20 -action_53 (60#) = happyShift action_21 -action_53 (61#) = happyShift action_22 -action_53 (69#) = happyShift action_23 -action_53 (70#) = happyShift action_24 -action_53 (74#) = happyShift action_25 -action_53 (76#) = happyShift action_26 -action_53 (81#) = happyShift action_27 -action_53 (83#) = happyShift action_28 -action_53 (85#) = happyShift action_29 -action_53 (86#) = happyShift action_30 -action_53 (87#) = happyShift action_31 -action_53 (6#) = happyGoto action_2 -action_53 (7#) = happyGoto action_118 -action_53 (9#) = happyGoto action_4 -action_53 (16#) = happyGoto action_5 -action_53 (17#) = happyGoto action_6 -action_53 (18#) = happyGoto action_7 -action_53 (21#) = happyGoto action_8 -action_53 (24#) = happyGoto action_9 -action_53 (25#) = happyGoto action_10 -action_53 (26#) = happyGoto action_11 -action_53 x = happyTcHack x happyFail - -action_54 (28#) = happyShift action_12 -action_54 (29#) = happyShift action_13 -action_54 (30#) = happyShift action_14 -action_54 (35#) = happyShift action_15 -action_54 (42#) = happyShift action_16 -action_54 (43#) = happyShift action_17 -action_54 (44#) = happyShift action_18 -action_54 (50#) = happyShift action_19 -action_54 (56#) = happyShift action_20 -action_54 (60#) = happyShift action_21 -action_54 (61#) = happyShift action_22 -action_54 (69#) = happyShift action_23 -action_54 (70#) = happyShift action_24 -action_54 (74#) = happyShift action_25 -action_54 (76#) = happyShift action_26 -action_54 (81#) = happyShift action_27 -action_54 (83#) = happyShift action_28 -action_54 (85#) = happyShift action_29 -action_54 (86#) = happyShift action_30 -action_54 (87#) = happyShift action_31 -action_54 (6#) = happyGoto action_2 -action_54 (7#) = happyGoto action_117 -action_54 (9#) = happyGoto action_4 -action_54 (16#) = happyGoto action_5 -action_54 (17#) = happyGoto action_6 -action_54 (18#) = happyGoto action_7 -action_54 (21#) = happyGoto action_8 -action_54 (24#) = happyGoto action_9 -action_54 (25#) = happyGoto action_10 -action_54 (26#) = happyGoto action_11 -action_54 x = happyTcHack x happyFail - -action_55 x = happyTcHack x happyReduce_2 - -action_56 (28#) = happyShift action_12 -action_56 (29#) = happyShift action_13 -action_56 (30#) = happyShift action_14 -action_56 (35#) = happyShift action_15 -action_56 (36#) = happyShift action_116 -action_56 (42#) = happyShift action_16 -action_56 (43#) = happyShift action_17 -action_56 (44#) = happyShift action_18 -action_56 (50#) = happyShift action_19 -action_56 (56#) = happyShift action_20 -action_56 (60#) = happyShift action_21 -action_56 (61#) = happyShift action_22 -action_56 (69#) = happyShift action_23 -action_56 (70#) = happyShift action_24 -action_56 (74#) = happyShift action_25 -action_56 (76#) = happyShift action_26 -action_56 (81#) = happyShift action_27 -action_56 (83#) = happyShift action_28 -action_56 (85#) = happyShift action_29 -action_56 (86#) = happyShift action_30 -action_56 (87#) = happyShift action_31 -action_56 (6#) = happyGoto action_2 -action_56 (7#) = happyGoto action_68 -action_56 (8#) = happyGoto action_115 -action_56 (9#) = happyGoto action_4 -action_56 (16#) = happyGoto action_5 -action_56 (17#) = happyGoto action_6 -action_56 (18#) = happyGoto action_7 -action_56 (21#) = happyGoto action_8 -action_56 (24#) = happyGoto action_9 -action_56 (25#) = happyGoto action_10 -action_56 (26#) = happyGoto action_11 -action_56 x = happyTcHack x happyFail - -action_57 (33#) = happyShift action_76 -action_57 (75#) = happyShift action_77 -action_57 (22#) = happyGoto action_114 -action_57 (23#) = happyGoto action_75 -action_57 x = happyTcHack x happyReduce_81 - -action_58 (76#) = happyShift action_113 -action_58 x = happyTcHack x happyFail - -action_59 (76#) = happyShift action_112 -action_59 x = happyTcHack x happyFail - -action_60 (64#) = happyShift action_111 -action_60 x = happyTcHack x happyFail - -action_61 (63#) = happyShift action_110 -action_61 x = happyTcHack x happyReduce_43 - -action_62 (62#) = happyShift action_109 -action_62 x = happyTcHack x happyFail - -action_63 (63#) = happyShift action_101 -action_63 x = happyTcHack x happyReduce_42 - -action_64 x = happyTcHack x happyReduce_36 - -action_65 (76#) = happyShift action_108 -action_65 (20#) = happyGoto action_107 -action_65 x = happyTcHack x happyReduce_66 - -action_66 x = happyTcHack x happyReduce_35 - -action_67 x = happyTcHack x happyReduce_34 - -action_68 (41#) = happyShift action_36 -action_68 (42#) = happyShift action_37 -action_68 (43#) = happyShift action_38 -action_68 (44#) = happyShift action_39 -action_68 (45#) = happyShift action_40 -action_68 (46#) = happyShift action_41 -action_68 (47#) = happyShift action_42 -action_68 (48#) = happyShift action_43 -action_68 (49#) = happyShift action_44 -action_68 (50#) = happyShift action_45 -action_68 (51#) = happyShift action_46 -action_68 (52#) = happyShift action_47 -action_68 (53#) = happyShift action_48 -action_68 (54#) = happyShift action_49 -action_68 (55#) = happyShift action_50 -action_68 (56#) = happyShift action_51 -action_68 (57#) = happyShift action_52 -action_68 (58#) = happyShift action_53 -action_68 (59#) = happyShift action_54 -action_68 x = happyTcHack x happyReduce_40 - -action_69 (36#) = happyShift action_105 -action_69 (63#) = happyShift action_106 -action_69 x = happyTcHack x happyFail - -action_70 x = happyTcHack x happyReduce_99 - -action_71 (31#) = happyShift action_104 -action_71 (41#) = happyShift action_36 -action_71 (42#) = happyShift action_37 -action_71 (43#) = happyShift action_38 -action_71 (44#) = happyShift action_39 -action_71 (45#) = happyShift action_40 -action_71 (46#) = happyShift action_41 -action_71 (47#) = happyShift action_42 -action_71 (48#) = happyShift action_43 -action_71 (49#) = happyShift action_44 -action_71 (50#) = happyShift action_45 -action_71 (51#) = happyShift action_46 -action_71 (52#) = happyShift action_47 -action_71 (53#) = happyShift action_48 -action_71 (54#) = happyShift action_49 -action_71 (55#) = happyShift action_50 -action_71 (56#) = happyShift action_51 -action_71 (57#) = happyShift action_52 -action_71 (58#) = happyShift action_53 -action_71 (59#) = happyShift action_54 -action_71 x = happyTcHack x happyFail - -action_72 (63#) = happyShift action_101 -action_72 (73#) = happyShift action_103 -action_72 x = happyTcHack x happyFail - -action_73 (63#) = happyShift action_101 -action_73 (73#) = happyShift action_102 -action_73 x = happyTcHack x happyFail - -action_74 (75#) = happyShift action_77 -action_74 (23#) = happyGoto action_100 -action_74 x = happyTcHack x happyReduce_82 - -action_75 x = happyTcHack x happyReduce_84 - -action_76 (28#) = happyShift action_12 -action_76 (29#) = happyShift action_13 -action_76 (30#) = happyShift action_14 -action_76 (35#) = happyShift action_15 -action_76 (42#) = happyShift action_16 -action_76 (43#) = happyShift action_17 -action_76 (44#) = happyShift action_18 -action_76 (50#) = happyShift action_19 -action_76 (56#) = happyShift action_20 -action_76 (60#) = happyShift action_21 -action_76 (61#) = happyShift action_22 -action_76 (69#) = happyShift action_23 -action_76 (70#) = happyShift action_24 -action_76 (74#) = happyShift action_25 -action_76 (76#) = happyShift action_26 -action_76 (81#) = happyShift action_27 -action_76 (83#) = happyShift action_28 -action_76 (85#) = happyShift action_29 -action_76 (86#) = happyShift action_30 -action_76 (87#) = happyShift action_31 -action_76 (6#) = happyGoto action_2 -action_76 (7#) = happyGoto action_99 -action_76 (9#) = happyGoto action_4 -action_76 (16#) = happyGoto action_5 -action_76 (17#) = happyGoto action_6 -action_76 (18#) = happyGoto action_7 -action_76 (21#) = happyGoto action_8 -action_76 (24#) = happyGoto action_9 -action_76 (25#) = happyGoto action_10 -action_76 (26#) = happyGoto action_11 -action_76 x = happyTcHack x happyFail - -action_77 (35#) = happyShift action_15 -action_77 (44#) = happyShift action_18 -action_77 (74#) = happyShift action_96 -action_77 (75#) = happyShift action_97 -action_77 (76#) = happyShift action_26 -action_77 (80#) = happyShift action_98 -action_77 (81#) = happyShift action_27 -action_77 (83#) = happyShift action_28 -action_77 (6#) = happyGoto action_2 -action_77 (24#) = happyGoto action_95 -action_77 (25#) = happyGoto action_10 -action_77 (26#) = happyGoto action_11 -action_77 x = happyTcHack x happyFail - -action_78 (37#) = happyShift action_91 -action_78 (50#) = happyShift action_19 -action_78 (71#) = happyShift action_92 -action_78 (84#) = happyShift action_93 -action_78 (87#) = happyShift action_94 -action_78 (17#) = happyGoto action_89 -action_78 (18#) = happyGoto action_7 -action_78 (19#) = happyGoto action_90 -action_78 x = happyTcHack x happyFail - -action_79 x = happyTcHack x happyReduce_65 - -action_80 (66#) = happyShift action_88 -action_80 (13#) = happyGoto action_87 -action_80 x = happyTcHack x happyReduce_55 - -action_81 (83#) = happyShift action_28 -action_81 (6#) = happyGoto action_62 -action_81 (10#) = happyGoto action_86 -action_81 x = happyTcHack x happyFail - -action_82 (83#) = happyShift action_28 -action_82 (6#) = happyGoto action_60 -action_82 (11#) = happyGoto action_85 -action_82 x = happyTcHack x happyFail - -action_83 (28#) = happyShift action_12 -action_83 (29#) = happyShift action_13 -action_83 (30#) = happyShift action_14 -action_83 (35#) = happyShift action_15 -action_83 (42#) = happyShift action_16 -action_83 (43#) = happyShift action_17 -action_83 (44#) = happyShift action_18 -action_83 (50#) = happyShift action_19 -action_83 (56#) = happyShift action_20 -action_83 (60#) = happyShift action_21 -action_83 (61#) = happyShift action_22 -action_83 (69#) = happyShift action_23 -action_83 (70#) = happyShift action_24 -action_83 (74#) = happyShift action_25 -action_83 (76#) = happyShift action_26 -action_83 (81#) = happyShift action_27 -action_83 (83#) = happyShift action_28 -action_83 (85#) = happyShift action_29 -action_83 (86#) = happyShift action_30 -action_83 (87#) = happyShift action_31 -action_83 (6#) = happyGoto action_2 -action_83 (7#) = happyGoto action_84 -action_83 (9#) = happyGoto action_4 -action_83 (16#) = happyGoto action_5 -action_83 (17#) = happyGoto action_6 -action_83 (18#) = happyGoto action_7 -action_83 (21#) = happyGoto action_8 -action_83 (24#) = happyGoto action_9 -action_83 (25#) = happyGoto action_10 -action_83 (26#) = happyGoto action_11 -action_83 x = happyTcHack x happyFail - -action_84 (41#) = happyShift action_36 -action_84 (42#) = happyShift action_37 -action_84 (43#) = happyShift action_38 -action_84 (44#) = happyShift action_39 -action_84 (45#) = happyShift action_40 -action_84 (46#) = happyShift action_41 -action_84 (47#) = happyShift action_42 -action_84 (48#) = happyShift action_43 -action_84 (49#) = happyShift action_44 -action_84 (50#) = happyShift action_45 -action_84 (51#) = happyShift action_46 -action_84 (52#) = happyShift action_47 -action_84 (53#) = happyShift action_48 -action_84 (54#) = happyShift action_49 -action_84 (55#) = happyShift action_50 -action_84 (56#) = happyShift action_51 -action_84 (57#) = happyShift action_52 -action_84 (58#) = happyShift action_53 -action_84 (59#) = happyShift action_54 -action_84 x = happyTcHack x happyReduce_52 - -action_85 (63#) = happyShift action_110 -action_85 x = happyTcHack x happyReduce_45 - -action_86 (63#) = happyShift action_101 -action_86 x = happyTcHack x happyReduce_44 - -action_87 (27#) = happyShift action_164 -action_87 x = happyTcHack x happyFail - -action_88 (28#) = happyShift action_12 -action_88 (29#) = happyShift action_13 -action_88 (30#) = happyShift action_14 -action_88 (35#) = happyShift action_15 -action_88 (42#) = happyShift action_16 -action_88 (43#) = happyShift action_17 -action_88 (44#) = happyShift action_18 -action_88 (50#) = happyShift action_19 -action_88 (56#) = happyShift action_20 -action_88 (60#) = happyShift action_21 -action_88 (61#) = happyShift action_22 -action_88 (69#) = happyShift action_23 -action_88 (70#) = happyShift action_24 -action_88 (74#) = happyShift action_25 -action_88 (76#) = happyShift action_26 -action_88 (81#) = happyShift action_27 -action_88 (83#) = happyShift action_28 -action_88 (85#) = happyShift action_29 -action_88 (86#) = happyShift action_30 -action_88 (87#) = happyShift action_31 -action_88 (6#) = happyGoto action_2 -action_88 (7#) = happyGoto action_162 -action_88 (9#) = happyGoto action_4 -action_88 (14#) = happyGoto action_163 -action_88 (16#) = happyGoto action_5 -action_88 (17#) = happyGoto action_6 -action_88 (18#) = happyGoto action_7 -action_88 (21#) = happyGoto action_8 -action_88 (24#) = happyGoto action_9 -action_88 (25#) = happyGoto action_10 -action_88 (26#) = happyGoto action_11 -action_88 x = happyTcHack x happyFail - -action_89 x = happyTcHack x happyReduce_71 - -action_90 (37#) = happyShift action_158 -action_90 (50#) = happyShift action_19 -action_90 (71#) = happyShift action_159 -action_90 (84#) = happyShift action_160 -action_90 (87#) = happyShift action_161 -action_90 (17#) = happyGoto action_157 -action_90 (18#) = happyGoto action_7 -action_90 x = happyTcHack x happyFail - -action_91 (28#) = happyShift action_12 -action_91 (29#) = happyShift action_13 -action_91 (30#) = happyShift action_14 -action_91 (35#) = happyShift action_15 -action_91 (42#) = happyShift action_16 -action_91 (43#) = happyShift action_17 -action_91 (44#) = happyShift action_18 -action_91 (50#) = happyShift action_19 -action_91 (56#) = happyShift action_20 -action_91 (60#) = happyShift action_21 -action_91 (61#) = happyShift action_22 -action_91 (69#) = happyShift action_23 -action_91 (70#) = happyShift action_24 -action_91 (74#) = happyShift action_25 -action_91 (76#) = happyShift action_26 -action_91 (81#) = happyShift action_27 -action_91 (83#) = happyShift action_28 -action_91 (85#) = happyShift action_29 -action_91 (86#) = happyShift action_30 -action_91 (87#) = happyShift action_31 -action_91 (6#) = happyGoto action_2 -action_91 (7#) = happyGoto action_68 -action_91 (8#) = happyGoto action_156 -action_91 (9#) = happyGoto action_4 -action_91 (16#) = happyGoto action_5 -action_91 (17#) = happyGoto action_6 -action_91 (18#) = happyGoto action_7 -action_91 (21#) = happyGoto action_8 -action_91 (24#) = happyGoto action_9 -action_91 (25#) = happyGoto action_10 -action_91 (26#) = happyGoto action_11 -action_91 x = happyTcHack x happyFail - -action_92 (76#) = happyShift action_155 -action_92 x = happyTcHack x happyFail - -action_93 x = happyTcHack x happyReduce_70 - -action_94 x = happyTcHack x happyReduce_69 - -action_95 (33#) = happyShift action_76 -action_95 x = happyTcHack x happyReduce_86 - -action_96 (35#) = happyShift action_15 -action_96 (44#) = happyShift action_18 -action_96 (76#) = happyShift action_26 -action_96 (81#) = happyShift action_27 -action_96 (83#) = happyShift action_28 -action_96 (6#) = happyGoto action_2 -action_96 (24#) = happyGoto action_154 -action_96 (25#) = happyGoto action_10 -action_96 (26#) = happyGoto action_11 -action_96 x = happyTcHack x happyFail - -action_97 (35#) = happyShift action_15 -action_97 (44#) = happyShift action_18 -action_97 (74#) = happyShift action_153 -action_97 (76#) = happyShift action_26 -action_97 (81#) = happyShift action_27 -action_97 (83#) = happyShift action_28 -action_97 (6#) = happyGoto action_2 -action_97 (24#) = happyGoto action_152 -action_97 (25#) = happyGoto action_10 -action_97 (26#) = happyGoto action_11 -action_97 x = happyTcHack x happyFail - -action_98 x = happyTcHack x happyReduce_90 - -action_99 (34#) = happyShift action_151 -action_99 (41#) = happyShift action_36 -action_99 (42#) = happyShift action_37 -action_99 (43#) = happyShift action_38 -action_99 (44#) = happyShift action_39 -action_99 (45#) = happyShift action_40 -action_99 (46#) = happyShift action_41 -action_99 (47#) = happyShift action_42 -action_99 (48#) = happyShift action_43 -action_99 (49#) = happyShift action_44 -action_99 (50#) = happyShift action_45 -action_99 (51#) = happyShift action_46 -action_99 (52#) = happyShift action_47 -action_99 (53#) = happyShift action_48 -action_99 (54#) = happyShift action_49 -action_99 (55#) = happyShift action_50 -action_99 (56#) = happyShift action_51 -action_99 (57#) = happyShift action_52 -action_99 (58#) = happyShift action_53 -action_99 (59#) = happyShift action_54 -action_99 x = happyTcHack x happyFail - -action_100 x = happyTcHack x happyReduce_85 - -action_101 (83#) = happyShift action_28 -action_101 (6#) = happyGoto action_150 -action_101 x = happyTcHack x happyFail - -action_102 (28#) = happyShift action_12 -action_102 (29#) = happyShift action_13 -action_102 (30#) = happyShift action_14 -action_102 (35#) = happyShift action_15 -action_102 (42#) = happyShift action_16 -action_102 (43#) = happyShift action_17 -action_102 (44#) = happyShift action_18 -action_102 (50#) = happyShift action_19 -action_102 (56#) = happyShift action_20 -action_102 (60#) = happyShift action_21 -action_102 (61#) = happyShift action_22 -action_102 (69#) = happyShift action_23 -action_102 (70#) = happyShift action_24 -action_102 (74#) = happyShift action_25 -action_102 (76#) = happyShift action_26 -action_102 (81#) = happyShift action_27 -action_102 (83#) = happyShift action_28 -action_102 (85#) = happyShift action_29 -action_102 (86#) = happyShift action_30 -action_102 (87#) = happyShift action_31 -action_102 (6#) = happyGoto action_2 -action_102 (7#) = happyGoto action_149 -action_102 (9#) = happyGoto action_4 -action_102 (16#) = happyGoto action_5 -action_102 (17#) = happyGoto action_6 -action_102 (18#) = happyGoto action_7 -action_102 (21#) = happyGoto action_8 -action_102 (24#) = happyGoto action_9 -action_102 (25#) = happyGoto action_10 -action_102 (26#) = happyGoto action_11 -action_102 x = happyTcHack x happyFail - -action_103 (28#) = happyShift action_12 -action_103 (29#) = happyShift action_13 -action_103 (30#) = happyShift action_14 -action_103 (35#) = happyShift action_15 -action_103 (42#) = happyShift action_16 -action_103 (43#) = happyShift action_17 -action_103 (44#) = happyShift action_18 -action_103 (50#) = happyShift action_19 -action_103 (56#) = happyShift action_20 -action_103 (60#) = happyShift action_21 -action_103 (61#) = happyShift action_22 -action_103 (69#) = happyShift action_23 -action_103 (70#) = happyShift action_24 -action_103 (74#) = happyShift action_25 -action_103 (76#) = happyShift action_26 -action_103 (81#) = happyShift action_27 -action_103 (83#) = happyShift action_28 -action_103 (85#) = happyShift action_29 -action_103 (86#) = happyShift action_30 -action_103 (87#) = happyShift action_31 -action_103 (6#) = happyGoto action_2 -action_103 (7#) = happyGoto action_148 -action_103 (9#) = happyGoto action_4 -action_103 (16#) = happyGoto action_5 -action_103 (17#) = happyGoto action_6 -action_103 (18#) = happyGoto action_7 -action_103 (21#) = happyGoto action_8 -action_103 (24#) = happyGoto action_9 -action_103 (25#) = happyGoto action_10 -action_103 (26#) = happyGoto action_11 -action_103 x = happyTcHack x happyFail - -action_104 (28#) = happyShift action_12 -action_104 (29#) = happyShift action_13 -action_104 (30#) = happyShift action_14 -action_104 (35#) = happyShift action_15 -action_104 (42#) = happyShift action_16 -action_104 (43#) = happyShift action_17 -action_104 (44#) = happyShift action_18 -action_104 (50#) = happyShift action_19 -action_104 (56#) = happyShift action_20 -action_104 (60#) = happyShift action_21 -action_104 (61#) = happyShift action_22 -action_104 (69#) = happyShift action_23 -action_104 (70#) = happyShift action_24 -action_104 (74#) = happyShift action_25 -action_104 (76#) = happyShift action_26 -action_104 (81#) = happyShift action_27 -action_104 (83#) = happyShift action_28 -action_104 (85#) = happyShift action_29 -action_104 (86#) = happyShift action_30 -action_104 (87#) = happyShift action_31 -action_104 (6#) = happyGoto action_2 -action_104 (7#) = happyGoto action_147 -action_104 (9#) = happyGoto action_4 -action_104 (16#) = happyGoto action_5 -action_104 (17#) = happyGoto action_6 -action_104 (18#) = happyGoto action_7 -action_104 (21#) = happyGoto action_8 -action_104 (24#) = happyGoto action_9 -action_104 (25#) = happyGoto action_10 -action_104 (26#) = happyGoto action_11 -action_104 x = happyTcHack x happyFail - -action_105 x = happyTcHack x happyReduce_98 - -action_106 (28#) = happyShift action_12 -action_106 (29#) = happyShift action_13 -action_106 (30#) = happyShift action_14 -action_106 (35#) = happyShift action_15 -action_106 (42#) = happyShift action_16 -action_106 (43#) = happyShift action_17 -action_106 (44#) = happyShift action_18 -action_106 (50#) = happyShift action_19 -action_106 (56#) = happyShift action_20 -action_106 (60#) = happyShift action_21 -action_106 (61#) = happyShift action_22 -action_106 (69#) = happyShift action_23 -action_106 (70#) = happyShift action_24 -action_106 (74#) = happyShift action_25 -action_106 (76#) = happyShift action_26 -action_106 (81#) = happyShift action_27 -action_106 (83#) = happyShift action_28 -action_106 (85#) = happyShift action_29 -action_106 (86#) = happyShift action_30 -action_106 (87#) = happyShift action_31 -action_106 (6#) = happyGoto action_2 -action_106 (7#) = happyGoto action_146 -action_106 (9#) = happyGoto action_4 -action_106 (16#) = happyGoto action_5 -action_106 (17#) = happyGoto action_6 -action_106 (18#) = happyGoto action_7 -action_106 (21#) = happyGoto action_8 -action_106 (24#) = happyGoto action_9 -action_106 (25#) = happyGoto action_10 -action_106 (26#) = happyGoto action_11 -action_106 x = happyTcHack x happyFail - -action_107 (76#) = happyShift action_145 -action_107 x = happyTcHack x happyReduce_67 - -action_108 (48#) = happyShift action_144 -action_108 x = happyTcHack x happyFail - -action_109 (28#) = happyShift action_12 -action_109 (29#) = happyShift action_13 -action_109 (30#) = happyShift action_14 -action_109 (35#) = happyShift action_15 -action_109 (42#) = happyShift action_16 -action_109 (43#) = happyShift action_17 -action_109 (44#) = happyShift action_18 -action_109 (50#) = happyShift action_19 -action_109 (56#) = happyShift action_20 -action_109 (60#) = happyShift action_21 -action_109 (61#) = happyShift action_22 -action_109 (69#) = happyShift action_23 -action_109 (70#) = happyShift action_24 -action_109 (74#) = happyShift action_25 -action_109 (76#) = happyShift action_26 -action_109 (81#) = happyShift action_27 -action_109 (83#) = happyShift action_28 -action_109 (85#) = happyShift action_29 -action_109 (86#) = happyShift action_30 -action_109 (87#) = happyShift action_31 -action_109 (6#) = happyGoto action_2 -action_109 (7#) = happyGoto action_143 -action_109 (9#) = happyGoto action_4 -action_109 (16#) = happyGoto action_5 -action_109 (17#) = happyGoto action_6 -action_109 (18#) = happyGoto action_7 -action_109 (21#) = happyGoto action_8 -action_109 (24#) = happyGoto action_9 -action_109 (25#) = happyGoto action_10 -action_109 (26#) = happyGoto action_11 -action_109 x = happyTcHack x happyFail - -action_110 (83#) = happyShift action_28 -action_110 (6#) = happyGoto action_142 -action_110 x = happyTcHack x happyFail - -action_111 (28#) = happyShift action_12 -action_111 (29#) = happyShift action_13 -action_111 (30#) = happyShift action_14 -action_111 (35#) = happyShift action_15 -action_111 (42#) = happyShift action_16 -action_111 (43#) = happyShift action_17 -action_111 (44#) = happyShift action_18 -action_111 (50#) = happyShift action_19 -action_111 (56#) = happyShift action_20 -action_111 (60#) = happyShift action_21 -action_111 (61#) = happyShift action_22 -action_111 (69#) = happyShift action_23 -action_111 (70#) = happyShift action_24 -action_111 (74#) = happyShift action_25 -action_111 (76#) = happyShift action_26 -action_111 (81#) = happyShift action_27 -action_111 (83#) = happyShift action_28 -action_111 (85#) = happyShift action_29 -action_111 (86#) = happyShift action_30 -action_111 (87#) = happyShift action_31 -action_111 (6#) = happyGoto action_2 -action_111 (7#) = happyGoto action_141 -action_111 (9#) = happyGoto action_4 -action_111 (16#) = happyGoto action_5 -action_111 (17#) = happyGoto action_6 -action_111 (18#) = happyGoto action_7 -action_111 (21#) = happyGoto action_8 -action_111 (24#) = happyGoto action_9 -action_111 (25#) = happyGoto action_10 -action_111 (26#) = happyGoto action_11 -action_111 x = happyTcHack x happyFail - -action_112 (36#) = happyShift action_140 -action_112 x = happyTcHack x happyFail - -action_113 (36#) = happyShift action_139 -action_113 x = happyTcHack x happyFail - -action_114 (75#) = happyShift action_77 -action_114 (23#) = happyGoto action_100 -action_114 x = happyTcHack x happyReduce_83 - -action_115 (36#) = happyShift action_138 -action_115 (63#) = happyShift action_106 -action_115 x = happyTcHack x happyFail - -action_116 x = happyTcHack x happyReduce_101 - -action_117 (41#) = happyShift action_36 -action_117 (42#) = happyShift action_37 -action_117 (43#) = happyShift action_38 -action_117 (44#) = happyShift action_39 -action_117 (45#) = happyShift action_40 -action_117 (46#) = happyShift action_41 -action_117 (47#) = happyShift action_42 -action_117 (48#) = happyShift action_43 -action_117 (49#) = happyShift action_44 -action_117 (50#) = happyShift action_45 -action_117 (51#) = happyShift action_46 -action_117 (52#) = happyShift action_47 -action_117 (53#) = happyShift action_48 -action_117 (54#) = happyShift action_49 -action_117 (55#) = happyShift action_50 -action_117 (56#) = happyShift action_51 -action_117 x = happyTcHack x happyReduce_33 - -action_118 (41#) = happyShift action_36 -action_118 (42#) = happyShift action_37 -action_118 (43#) = happyShift action_38 -action_118 (44#) = happyShift action_39 -action_118 (45#) = happyShift action_40 -action_118 (46#) = happyShift action_41 -action_118 (47#) = happyShift action_42 -action_118 (48#) = happyShift action_43 -action_118 (49#) = happyShift action_44 -action_118 (50#) = happyShift action_45 -action_118 (51#) = happyShift action_46 -action_118 (52#) = happyShift action_47 -action_118 (53#) = happyShift action_48 -action_118 (54#) = happyShift action_49 -action_118 (55#) = happyShift action_50 -action_118 (56#) = happyShift action_51 -action_118 x = happyTcHack x happyReduce_32 - -action_119 (41#) = happyShift action_36 -action_119 (42#) = happyShift action_37 -action_119 (43#) = happyShift action_38 -action_119 (44#) = happyShift action_39 -action_119 (45#) = happyShift action_40 -action_119 (46#) = happyShift action_41 -action_119 (47#) = happyShift action_42 -action_119 (48#) = happyShift action_43 -action_119 (49#) = happyShift action_44 -action_119 (50#) = happyShift action_45 -action_119 (51#) = happyShift action_46 -action_119 (52#) = happyShift action_47 -action_119 (53#) = happyShift action_48 -action_119 (54#) = happyShift action_49 -action_119 (55#) = happyShift action_50 -action_119 (56#) = happyShift action_51 -action_119 x = happyTcHack x happyReduce_31 - -action_120 (41#) = happyShift action_36 -action_120 (42#) = happyShift action_37 -action_120 (43#) = happyShift action_38 -action_120 (44#) = happyShift action_39 -action_120 (45#) = happyShift action_40 -action_120 (46#) = happyShift action_41 -action_120 (47#) = happyShift action_42 -action_120 (48#) = happyShift action_43 -action_120 (49#) = happyShift action_44 -action_120 (50#) = happyShift action_45 -action_120 (51#) = happyShift action_46 -action_120 (52#) = happyShift action_47 -action_120 (53#) = happyShift action_48 -action_120 (56#) = happyFail -action_120 x = happyTcHack x happyReduce_30 - -action_121 (41#) = happyShift action_36 -action_121 (42#) = happyShift action_37 -action_121 (43#) = happyShift action_38 -action_121 (44#) = happyShift action_39 -action_121 (45#) = happyShift action_40 -action_121 (46#) = happyShift action_41 -action_121 (47#) = happyShift action_42 -action_121 (48#) = happyShift action_43 -action_121 (49#) = happyShift action_44 -action_121 (50#) = happyShift action_45 -action_121 (51#) = happyShift action_46 -action_121 (52#) = happyShift action_47 -action_121 (53#) = happyShift action_48 -action_121 (54#) = happyShift action_49 -action_121 (55#) = happyShift action_50 -action_121 (56#) = happyShift action_51 -action_121 x = happyTcHack x happyReduce_29 - -action_122 (41#) = happyShift action_36 -action_122 (42#) = happyShift action_37 -action_122 (43#) = happyShift action_38 -action_122 (44#) = happyShift action_39 -action_122 (45#) = happyShift action_40 -action_122 (46#) = happyShift action_41 -action_122 (47#) = happyShift action_42 -action_122 (48#) = happyShift action_43 -action_122 (49#) = happyShift action_44 -action_122 (50#) = happyShift action_45 -action_122 (51#) = happyShift action_46 -action_122 (52#) = happyShift action_47 -action_122 (53#) = happyShift action_48 -action_122 (54#) = happyShift action_49 -action_122 (56#) = happyShift action_51 -action_122 x = happyTcHack x happyReduce_28 - -action_123 (42#) = happyShift action_37 -action_123 (43#) = happyShift action_38 -action_123 (44#) = happyShift action_39 -action_123 (45#) = happyShift action_40 -action_123 (46#) = happyShift action_41 -action_123 (47#) = happyShift action_42 -action_123 x = happyTcHack x happyReduce_27 - -action_124 (42#) = happyShift action_37 -action_124 (43#) = happyShift action_38 -action_124 (44#) = happyShift action_39 -action_124 (45#) = happyShift action_40 -action_124 (46#) = happyShift action_41 -action_124 (47#) = happyShift action_42 -action_124 x = happyTcHack x happyReduce_26 - -action_125 (42#) = happyShift action_37 -action_125 (43#) = happyShift action_38 -action_125 (44#) = happyShift action_39 -action_125 (45#) = happyShift action_40 -action_125 (46#) = happyShift action_41 -action_125 (47#) = happyShift action_42 -action_125 x = happyTcHack x happyReduce_25 - -action_126 (42#) = happyShift action_37 -action_126 (43#) = happyShift action_38 -action_126 (44#) = happyShift action_39 -action_126 (45#) = happyShift action_40 -action_126 (46#) = happyShift action_41 -action_126 (47#) = happyShift action_42 -action_126 x = happyTcHack x happyReduce_24 - -action_127 (42#) = happyShift action_37 -action_127 (43#) = happyShift action_38 -action_127 (44#) = happyShift action_39 -action_127 (45#) = happyShift action_40 -action_127 (46#) = happyShift action_41 -action_127 (47#) = happyShift action_42 -action_127 x = happyTcHack x happyReduce_23 - -action_128 (42#) = happyShift action_37 -action_128 (43#) = happyShift action_38 -action_128 (44#) = happyShift action_39 -action_128 (45#) = happyShift action_40 -action_128 (46#) = happyShift action_41 -action_128 (47#) = happyShift action_42 -action_128 x = happyTcHack x happyReduce_22 - -action_129 x = happyTcHack x happyReduce_21 - -action_130 x = happyTcHack x happyReduce_20 - -action_131 x = happyTcHack x happyReduce_19 - -action_132 x = happyTcHack x happyReduce_18 - -action_133 (44#) = happyShift action_39 -action_133 (45#) = happyShift action_40 -action_133 (46#) = happyShift action_41 -action_133 (47#) = happyShift action_42 -action_133 x = happyTcHack x happyReduce_17 - -action_134 (44#) = happyShift action_39 -action_134 (45#) = happyShift action_40 -action_134 (46#) = happyShift action_41 -action_134 (47#) = happyShift action_42 -action_134 x = happyTcHack x happyReduce_16 - -action_135 (42#) = happyShift action_37 -action_135 (43#) = happyShift action_38 -action_135 (44#) = happyShift action_39 -action_135 (45#) = happyShift action_40 -action_135 (46#) = happyShift action_41 -action_135 (47#) = happyShift action_42 -action_135 (48#) = happyShift action_43 -action_135 (49#) = happyShift action_44 -action_135 (50#) = happyShift action_45 -action_135 (51#) = happyShift action_46 -action_135 (52#) = happyShift action_47 -action_135 (53#) = happyShift action_48 -action_135 x = happyTcHack x happyReduce_15 - -action_136 (35#) = happyShift action_137 -action_136 x = happyTcHack x happyFail - -action_137 (36#) = happyShift action_184 -action_137 (83#) = happyShift action_28 -action_137 (5#) = happyGoto action_182 -action_137 (6#) = happyGoto action_183 -action_137 x = happyTcHack x happyFail - -action_138 x = happyTcHack x happyReduce_100 - -action_139 x = happyTcHack x happyReduce_62 - -action_140 x = happyTcHack x happyReduce_61 - -action_141 (41#) = happyShift action_36 -action_141 (42#) = happyShift action_37 -action_141 (43#) = happyShift action_38 -action_141 (44#) = happyShift action_39 -action_141 (45#) = happyShift action_40 -action_141 (46#) = happyShift action_41 -action_141 (47#) = happyShift action_42 -action_141 (48#) = happyShift action_43 -action_141 (49#) = happyShift action_44 -action_141 (50#) = happyShift action_45 -action_141 (51#) = happyShift action_46 -action_141 (52#) = happyShift action_47 -action_141 (53#) = happyShift action_48 -action_141 (54#) = happyShift action_49 -action_141 (55#) = happyShift action_50 -action_141 (56#) = happyShift action_51 -action_141 (57#) = happyShift action_52 -action_141 (58#) = happyShift action_53 -action_141 (59#) = happyShift action_54 -action_141 x = happyTcHack x happyReduce_50 - -action_142 (64#) = happyShift action_181 -action_142 x = happyTcHack x happyFail - -action_143 (41#) = happyShift action_36 -action_143 (42#) = happyShift action_37 -action_143 (43#) = happyShift action_38 -action_143 (44#) = happyShift action_39 -action_143 (45#) = happyShift action_40 -action_143 (46#) = happyShift action_41 -action_143 (47#) = happyShift action_42 -action_143 (48#) = happyShift action_43 -action_143 (49#) = happyShift action_44 -action_143 (50#) = happyShift action_45 -action_143 (51#) = happyShift action_46 -action_143 (52#) = happyShift action_47 -action_143 (53#) = happyShift action_48 -action_143 (54#) = happyShift action_49 -action_143 (55#) = happyShift action_50 -action_143 (56#) = happyShift action_51 -action_143 (57#) = happyShift action_52 -action_143 (58#) = happyShift action_53 -action_143 (59#) = happyShift action_54 -action_143 (79#) = happyShift action_180 -action_143 x = happyTcHack x happyReduce_46 - -action_144 (39#) = happyShift action_178 -action_144 (87#) = happyShift action_179 -action_144 x = happyTcHack x happyFail - -action_145 (48#) = happyShift action_177 -action_145 x = happyTcHack x happyFail - -action_146 (41#) = happyShift action_36 -action_146 (42#) = happyShift action_37 -action_146 (43#) = happyShift action_38 -action_146 (44#) = happyShift action_39 -action_146 (45#) = happyShift action_40 -action_146 (46#) = happyShift action_41 -action_146 (47#) = happyShift action_42 -action_146 (48#) = happyShift action_43 -action_146 (49#) = happyShift action_44 -action_146 (50#) = happyShift action_45 -action_146 (51#) = happyShift action_46 -action_146 (52#) = happyShift action_47 -action_146 (53#) = happyShift action_48 -action_146 (54#) = happyShift action_49 -action_146 (55#) = happyShift action_50 -action_146 (56#) = happyShift action_51 -action_146 (57#) = happyShift action_52 -action_146 (58#) = happyShift action_53 -action_146 (59#) = happyShift action_54 -action_146 x = happyTcHack x happyReduce_41 - -action_147 (32#) = happyShift action_176 -action_147 (41#) = happyShift action_36 -action_147 (42#) = happyShift action_37 -action_147 (43#) = happyShift action_38 -action_147 (44#) = happyShift action_39 -action_147 (45#) = happyShift action_40 -action_147 (46#) = happyShift action_41 -action_147 (47#) = happyShift action_42 -action_147 (48#) = happyShift action_43 -action_147 (49#) = happyShift action_44 -action_147 (50#) = happyShift action_45 -action_147 (51#) = happyShift action_46 -action_147 (52#) = happyShift action_47 -action_147 (53#) = happyShift action_48 -action_147 (54#) = happyShift action_49 -action_147 (55#) = happyShift action_50 -action_147 (56#) = happyShift action_51 -action_147 (57#) = happyShift action_52 -action_147 (58#) = happyShift action_53 -action_147 (59#) = happyShift action_54 -action_147 x = happyTcHack x happyFail - -action_148 (41#) = happyShift action_36 -action_148 (42#) = happyShift action_37 -action_148 (43#) = happyShift action_38 -action_148 (44#) = happyShift action_39 -action_148 (45#) = happyShift action_40 -action_148 (46#) = happyShift action_41 -action_148 (47#) = happyShift action_42 -action_148 (48#) = happyShift action_43 -action_148 (49#) = happyShift action_44 -action_148 (50#) = happyShift action_45 -action_148 (51#) = happyShift action_46 -action_148 (52#) = happyShift action_47 -action_148 (53#) = happyShift action_48 -action_148 (54#) = happyShift action_49 -action_148 (55#) = happyShift action_50 -action_148 (56#) = happyShift action_51 -action_148 (57#) = happyShift action_52 -action_148 (58#) = happyShift action_53 -action_148 (59#) = happyShift action_54 -action_148 x = happyTcHack x happyReduce_10 - -action_149 (41#) = happyShift action_36 -action_149 (42#) = happyShift action_37 -action_149 (43#) = happyShift action_38 -action_149 (44#) = happyShift action_39 -action_149 (45#) = happyShift action_40 -action_149 (46#) = happyShift action_41 -action_149 (47#) = happyShift action_42 -action_149 (48#) = happyShift action_43 -action_149 (49#) = happyShift action_44 -action_149 (50#) = happyShift action_45 -action_149 (51#) = happyShift action_46 -action_149 (52#) = happyShift action_47 -action_149 (53#) = happyShift action_48 -action_149 (54#) = happyShift action_49 -action_149 (55#) = happyShift action_50 -action_149 (56#) = happyShift action_51 -action_149 (57#) = happyShift action_52 -action_149 (58#) = happyShift action_53 -action_149 (59#) = happyShift action_54 -action_149 x = happyTcHack x happyReduce_9 - -action_150 (62#) = happyShift action_175 -action_150 x = happyTcHack x happyFail - -action_151 x = happyTcHack x happyReduce_92 - -action_152 (33#) = happyShift action_76 -action_152 x = happyTcHack x happyReduce_88 - -action_153 (35#) = happyShift action_15 -action_153 (44#) = happyShift action_18 -action_153 (76#) = happyShift action_26 -action_153 (81#) = happyShift action_27 -action_153 (83#) = happyShift action_28 -action_153 (6#) = happyGoto action_2 -action_153 (24#) = happyGoto action_174 -action_153 (25#) = happyGoto action_10 -action_153 (26#) = happyGoto action_11 -action_153 x = happyTcHack x happyFail - -action_154 (33#) = happyShift action_76 -action_154 x = happyTcHack x happyReduce_87 - -action_155 (52#) = happyShift action_173 -action_155 x = happyTcHack x happyFail - -action_156 (38#) = happyShift action_172 -action_156 (63#) = happyShift action_106 -action_156 x = happyTcHack x happyFail - -action_157 x = happyTcHack x happyReduce_75 - -action_158 (28#) = happyShift action_12 -action_158 (29#) = happyShift action_13 -action_158 (30#) = happyShift action_14 -action_158 (35#) = happyShift action_15 -action_158 (42#) = happyShift action_16 -action_158 (43#) = happyShift action_17 -action_158 (44#) = happyShift action_18 -action_158 (50#) = happyShift action_19 -action_158 (56#) = happyShift action_20 -action_158 (60#) = happyShift action_21 -action_158 (61#) = happyShift action_22 -action_158 (69#) = happyShift action_23 -action_158 (70#) = happyShift action_24 -action_158 (74#) = happyShift action_25 -action_158 (76#) = happyShift action_26 -action_158 (81#) = happyShift action_27 -action_158 (83#) = happyShift action_28 -action_158 (85#) = happyShift action_29 -action_158 (86#) = happyShift action_30 -action_158 (87#) = happyShift action_31 -action_158 (6#) = happyGoto action_2 -action_158 (7#) = happyGoto action_68 -action_158 (8#) = happyGoto action_171 -action_158 (9#) = happyGoto action_4 -action_158 (16#) = happyGoto action_5 -action_158 (17#) = happyGoto action_6 -action_158 (18#) = happyGoto action_7 -action_158 (21#) = happyGoto action_8 -action_158 (24#) = happyGoto action_9 -action_158 (25#) = happyGoto action_10 -action_158 (26#) = happyGoto action_11 -action_158 x = happyTcHack x happyFail - -action_159 (76#) = happyShift action_170 -action_159 x = happyTcHack x happyFail - -action_160 x = happyTcHack x happyReduce_74 - -action_161 x = happyTcHack x happyReduce_73 - -action_162 (41#) = happyShift action_36 -action_162 (42#) = happyShift action_37 -action_162 (43#) = happyShift action_38 -action_162 (44#) = happyShift action_39 -action_162 (45#) = happyShift action_40 -action_162 (46#) = happyShift action_41 -action_162 (47#) = happyShift action_42 -action_162 (48#) = happyShift action_43 -action_162 (49#) = happyShift action_44 -action_162 (50#) = happyShift action_45 -action_162 (51#) = happyShift action_46 -action_162 (52#) = happyShift action_47 -action_162 (53#) = happyShift action_48 -action_162 (54#) = happyShift action_49 -action_162 (55#) = happyShift action_50 -action_162 (56#) = happyShift action_51 -action_162 (57#) = happyShift action_52 -action_162 (58#) = happyShift action_53 -action_162 (59#) = happyShift action_54 -action_162 (67#) = happyShift action_168 -action_162 (68#) = happyShift action_169 -action_162 (15#) = happyGoto action_167 -action_162 x = happyTcHack x happyReduce_60 - -action_163 (63#) = happyShift action_166 -action_163 x = happyTcHack x happyReduce_54 - -action_164 (28#) = happyShift action_12 -action_164 (29#) = happyShift action_13 -action_164 (30#) = happyShift action_14 -action_164 (35#) = happyShift action_15 -action_164 (42#) = happyShift action_16 -action_164 (43#) = happyShift action_17 -action_164 (44#) = happyShift action_18 -action_164 (50#) = happyShift action_19 -action_164 (56#) = happyShift action_20 -action_164 (60#) = happyShift action_21 -action_164 (61#) = happyShift action_22 -action_164 (69#) = happyShift action_23 -action_164 (70#) = happyShift action_24 -action_164 (74#) = happyShift action_25 -action_164 (76#) = happyShift action_26 -action_164 (81#) = happyShift action_27 -action_164 (83#) = happyShift action_28 -action_164 (85#) = happyShift action_29 -action_164 (86#) = happyShift action_30 -action_164 (87#) = happyShift action_31 -action_164 (6#) = happyGoto action_2 -action_164 (7#) = happyGoto action_165 -action_164 (9#) = happyGoto action_4 -action_164 (16#) = happyGoto action_5 -action_164 (17#) = happyGoto action_6 -action_164 (18#) = happyGoto action_7 -action_164 (21#) = happyGoto action_8 -action_164 (24#) = happyGoto action_9 -action_164 (25#) = happyGoto action_10 -action_164 (26#) = happyGoto action_11 -action_164 x = happyTcHack x happyFail - -action_165 (41#) = happyShift action_36 -action_165 (42#) = happyShift action_37 -action_165 (43#) = happyShift action_38 -action_165 (44#) = happyShift action_39 -action_165 (45#) = happyShift action_40 -action_165 (46#) = happyShift action_41 -action_165 (47#) = happyShift action_42 -action_165 (48#) = happyShift action_43 -action_165 (49#) = happyShift action_44 -action_165 (50#) = happyShift action_45 -action_165 (51#) = happyShift action_46 -action_165 (52#) = happyShift action_47 -action_165 (53#) = happyShift action_48 -action_165 (54#) = happyShift action_49 -action_165 (55#) = happyShift action_50 -action_165 (56#) = happyShift action_51 -action_165 (57#) = happyShift action_52 -action_165 (58#) = happyShift action_53 -action_165 (59#) = happyShift action_54 -action_165 x = happyTcHack x happyReduce_8 - -action_166 (28#) = happyShift action_12 -action_166 (29#) = happyShift action_13 -action_166 (30#) = happyShift action_14 -action_166 (35#) = happyShift action_15 -action_166 (42#) = happyShift action_16 -action_166 (43#) = happyShift action_17 -action_166 (44#) = happyShift action_18 -action_166 (50#) = happyShift action_19 -action_166 (56#) = happyShift action_20 -action_166 (60#) = happyShift action_21 -action_166 (61#) = happyShift action_22 -action_166 (69#) = happyShift action_23 -action_166 (70#) = happyShift action_24 -action_166 (74#) = happyShift action_25 -action_166 (76#) = happyShift action_26 -action_166 (81#) = happyShift action_27 -action_166 (83#) = happyShift action_28 -action_166 (85#) = happyShift action_29 -action_166 (86#) = happyShift action_30 -action_166 (87#) = happyShift action_31 -action_166 (6#) = happyGoto action_2 -action_166 (7#) = happyGoto action_197 -action_166 (9#) = happyGoto action_4 -action_166 (16#) = happyGoto action_5 -action_166 (17#) = happyGoto action_6 -action_166 (18#) = happyGoto action_7 -action_166 (21#) = happyGoto action_8 -action_166 (24#) = happyGoto action_9 -action_166 (25#) = happyGoto action_10 -action_166 (26#) = happyGoto action_11 -action_166 x = happyTcHack x happyFail - -action_167 x = happyTcHack x happyReduce_56 - -action_168 x = happyTcHack x happyReduce_58 - -action_169 x = happyTcHack x happyReduce_59 - -action_170 (52#) = happyShift action_196 -action_170 x = happyTcHack x happyFail - -action_171 (38#) = happyShift action_195 -action_171 (63#) = happyShift action_106 -action_171 x = happyTcHack x happyFail - -action_172 x = happyTcHack x happyReduce_68 - -action_173 x = happyTcHack x happyReduce_64 - -action_174 (33#) = happyShift action_76 -action_174 x = happyTcHack x happyReduce_89 - -action_175 (28#) = happyShift action_12 -action_175 (29#) = happyShift action_13 -action_175 (30#) = happyShift action_14 -action_175 (35#) = happyShift action_15 -action_175 (42#) = happyShift action_16 -action_175 (43#) = happyShift action_17 -action_175 (44#) = happyShift action_18 -action_175 (50#) = happyShift action_19 -action_175 (56#) = happyShift action_20 -action_175 (60#) = happyShift action_21 -action_175 (61#) = happyShift action_22 -action_175 (69#) = happyShift action_23 -action_175 (70#) = happyShift action_24 -action_175 (74#) = happyShift action_25 -action_175 (76#) = happyShift action_26 -action_175 (81#) = happyShift action_27 -action_175 (83#) = happyShift action_28 -action_175 (85#) = happyShift action_29 -action_175 (86#) = happyShift action_30 -action_175 (87#) = happyShift action_31 -action_175 (6#) = happyGoto action_2 -action_175 (7#) = happyGoto action_194 -action_175 (9#) = happyGoto action_4 -action_175 (16#) = happyGoto action_5 -action_175 (17#) = happyGoto action_6 -action_175 (18#) = happyGoto action_7 -action_175 (21#) = happyGoto action_8 -action_175 (24#) = happyGoto action_9 -action_175 (25#) = happyGoto action_10 -action_175 (26#) = happyGoto action_11 -action_175 x = happyTcHack x happyFail - -action_176 (28#) = happyShift action_12 -action_176 (29#) = happyShift action_13 -action_176 (30#) = happyShift action_14 -action_176 (35#) = happyShift action_15 -action_176 (42#) = happyShift action_16 -action_176 (43#) = happyShift action_17 -action_176 (44#) = happyShift action_18 -action_176 (50#) = happyShift action_19 -action_176 (56#) = happyShift action_20 -action_176 (60#) = happyShift action_21 -action_176 (61#) = happyShift action_22 -action_176 (69#) = happyShift action_23 -action_176 (70#) = happyShift action_24 -action_176 (74#) = happyShift action_25 -action_176 (76#) = happyShift action_26 -action_176 (81#) = happyShift action_27 -action_176 (83#) = happyShift action_28 -action_176 (85#) = happyShift action_29 -action_176 (86#) = happyShift action_30 -action_176 (87#) = happyShift action_31 -action_176 (6#) = happyGoto action_2 -action_176 (7#) = happyGoto action_193 -action_176 (9#) = happyGoto action_4 -action_176 (16#) = happyGoto action_5 -action_176 (17#) = happyGoto action_6 -action_176 (18#) = happyGoto action_7 -action_176 (21#) = happyGoto action_8 -action_176 (24#) = happyGoto action_9 -action_176 (25#) = happyGoto action_10 -action_176 (26#) = happyGoto action_11 -action_176 x = happyTcHack x happyFail - -action_177 (39#) = happyShift action_191 -action_177 (87#) = happyShift action_192 -action_177 x = happyTcHack x happyFail - -action_178 (28#) = happyShift action_12 -action_178 (29#) = happyShift action_13 -action_178 (30#) = happyShift action_14 -action_178 (35#) = happyShift action_15 -action_178 (42#) = happyShift action_16 -action_178 (43#) = happyShift action_17 -action_178 (44#) = happyShift action_18 -action_178 (50#) = happyShift action_19 -action_178 (56#) = happyShift action_20 -action_178 (60#) = happyShift action_21 -action_178 (61#) = happyShift action_22 -action_178 (69#) = happyShift action_23 -action_178 (70#) = happyShift action_24 -action_178 (74#) = happyShift action_25 -action_178 (76#) = happyShift action_26 -action_178 (81#) = happyShift action_27 -action_178 (83#) = happyShift action_28 -action_178 (85#) = happyShift action_29 -action_178 (86#) = happyShift action_30 -action_178 (87#) = happyShift action_31 -action_178 (6#) = happyGoto action_2 -action_178 (7#) = happyGoto action_190 -action_178 (9#) = happyGoto action_4 -action_178 (16#) = happyGoto action_5 -action_178 (17#) = happyGoto action_6 -action_178 (18#) = happyGoto action_7 -action_178 (21#) = happyGoto action_8 -action_178 (24#) = happyGoto action_9 -action_178 (25#) = happyGoto action_10 -action_178 (26#) = happyGoto action_11 -action_178 x = happyTcHack x happyFail - -action_179 x = happyTcHack x happyReduce_76 - -action_180 (83#) = happyShift action_28 -action_180 (6#) = happyGoto action_189 -action_180 x = happyTcHack x happyFail - -action_181 (28#) = happyShift action_12 -action_181 (29#) = happyShift action_13 -action_181 (30#) = happyShift action_14 -action_181 (35#) = happyShift action_15 -action_181 (42#) = happyShift action_16 -action_181 (43#) = happyShift action_17 -action_181 (44#) = happyShift action_18 -action_181 (50#) = happyShift action_19 -action_181 (56#) = happyShift action_20 -action_181 (60#) = happyShift action_21 -action_181 (61#) = happyShift action_22 -action_181 (69#) = happyShift action_23 -action_181 (70#) = happyShift action_24 -action_181 (74#) = happyShift action_25 -action_181 (76#) = happyShift action_26 -action_181 (81#) = happyShift action_27 -action_181 (83#) = happyShift action_28 -action_181 (85#) = happyShift action_29 -action_181 (86#) = happyShift action_30 -action_181 (87#) = happyShift action_31 -action_181 (6#) = happyGoto action_2 -action_181 (7#) = happyGoto action_188 -action_181 (9#) = happyGoto action_4 -action_181 (16#) = happyGoto action_5 -action_181 (17#) = happyGoto action_6 -action_181 (18#) = happyGoto action_7 -action_181 (21#) = happyGoto action_8 -action_181 (24#) = happyGoto action_9 -action_181 (25#) = happyGoto action_10 -action_181 (26#) = happyGoto action_11 -action_181 x = happyTcHack x happyFail - -action_182 (36#) = happyShift action_186 -action_182 (63#) = happyShift action_187 -action_182 x = happyTcHack x happyFail - -action_183 x = happyTcHack x happyReduce_5 - -action_184 (48#) = happyShift action_185 -action_184 x = happyTcHack x happyFail - -action_185 (28#) = happyShift action_12 -action_185 (29#) = happyShift action_13 -action_185 (30#) = happyShift action_14 -action_185 (35#) = happyShift action_15 -action_185 (42#) = happyShift action_16 -action_185 (43#) = happyShift action_17 -action_185 (44#) = happyShift action_18 -action_185 (50#) = happyShift action_19 -action_185 (56#) = happyShift action_20 -action_185 (60#) = happyShift action_21 -action_185 (61#) = happyShift action_22 -action_185 (69#) = happyShift action_23 -action_185 (70#) = happyShift action_24 -action_185 (74#) = happyShift action_25 -action_185 (76#) = happyShift action_26 -action_185 (81#) = happyShift action_27 -action_185 (83#) = happyShift action_28 -action_185 (85#) = happyShift action_29 -action_185 (86#) = happyShift action_30 -action_185 (87#) = happyShift action_31 -action_185 (6#) = happyGoto action_2 -action_185 (7#) = happyGoto action_204 -action_185 (9#) = happyGoto action_4 -action_185 (16#) = happyGoto action_5 -action_185 (17#) = happyGoto action_6 -action_185 (18#) = happyGoto action_7 -action_185 (21#) = happyGoto action_8 -action_185 (24#) = happyGoto action_9 -action_185 (25#) = happyGoto action_10 -action_185 (26#) = happyGoto action_11 -action_185 x = happyTcHack x happyFail - -action_186 (48#) = happyShift action_203 -action_186 x = happyTcHack x happyFail - -action_187 (83#) = happyShift action_28 -action_187 (6#) = happyGoto action_202 -action_187 x = happyTcHack x happyFail - -action_188 (41#) = happyShift action_36 -action_188 (42#) = happyShift action_37 -action_188 (43#) = happyShift action_38 -action_188 (44#) = happyShift action_39 -action_188 (45#) = happyShift action_40 -action_188 (46#) = happyShift action_41 -action_188 (47#) = happyShift action_42 -action_188 (48#) = happyShift action_43 -action_188 (49#) = happyShift action_44 -action_188 (50#) = happyShift action_45 -action_188 (51#) = happyShift action_46 -action_188 (52#) = happyShift action_47 -action_188 (53#) = happyShift action_48 -action_188 (54#) = happyShift action_49 -action_188 (55#) = happyShift action_50 -action_188 (56#) = happyShift action_51 -action_188 (57#) = happyShift action_52 -action_188 (58#) = happyShift action_53 -action_188 (59#) = happyShift action_54 -action_188 x = happyTcHack x happyReduce_51 - -action_189 x = happyTcHack x happyReduce_47 - -action_190 (40#) = happyShift action_201 -action_190 (41#) = happyShift action_36 -action_190 (42#) = happyShift action_37 -action_190 (43#) = happyShift action_38 -action_190 (44#) = happyShift action_39 -action_190 (45#) = happyShift action_40 -action_190 (46#) = happyShift action_41 -action_190 (47#) = happyShift action_42 -action_190 (48#) = happyShift action_43 -action_190 (49#) = happyShift action_44 -action_190 (50#) = happyShift action_45 -action_190 (51#) = happyShift action_46 -action_190 (52#) = happyShift action_47 -action_190 (53#) = happyShift action_48 -action_190 (54#) = happyShift action_49 -action_190 (55#) = happyShift action_50 -action_190 (56#) = happyShift action_51 -action_190 (57#) = happyShift action_52 -action_190 (58#) = happyShift action_53 -action_190 (59#) = happyShift action_54 -action_190 x = happyTcHack x happyFail - -action_191 (28#) = happyShift action_12 -action_191 (29#) = happyShift action_13 -action_191 (30#) = happyShift action_14 -action_191 (35#) = happyShift action_15 -action_191 (42#) = happyShift action_16 -action_191 (43#) = happyShift action_17 -action_191 (44#) = happyShift action_18 -action_191 (50#) = happyShift action_19 -action_191 (56#) = happyShift action_20 -action_191 (60#) = happyShift action_21 -action_191 (61#) = happyShift action_22 -action_191 (69#) = happyShift action_23 -action_191 (70#) = happyShift action_24 -action_191 (74#) = happyShift action_25 -action_191 (76#) = happyShift action_26 -action_191 (81#) = happyShift action_27 -action_191 (83#) = happyShift action_28 -action_191 (85#) = happyShift action_29 -action_191 (86#) = happyShift action_30 -action_191 (87#) = happyShift action_31 -action_191 (6#) = happyGoto action_2 -action_191 (7#) = happyGoto action_200 -action_191 (9#) = happyGoto action_4 -action_191 (16#) = happyGoto action_5 -action_191 (17#) = happyGoto action_6 -action_191 (18#) = happyGoto action_7 -action_191 (21#) = happyGoto action_8 -action_191 (24#) = happyGoto action_9 -action_191 (25#) = happyGoto action_10 -action_191 (26#) = happyGoto action_11 -action_191 x = happyTcHack x happyFail - -action_192 x = happyTcHack x happyReduce_78 - -action_193 (41#) = happyShift action_36 -action_193 (42#) = happyShift action_37 -action_193 (43#) = happyShift action_38 -action_193 (44#) = happyShift action_39 -action_193 (45#) = happyShift action_40 -action_193 (46#) = happyShift action_41 -action_193 (47#) = happyShift action_42 -action_193 (48#) = happyShift action_43 -action_193 (49#) = happyShift action_44 -action_193 (50#) = happyShift action_45 -action_193 (51#) = happyShift action_46 -action_193 (52#) = happyShift action_47 -action_193 (53#) = happyShift action_48 -action_193 (54#) = happyShift action_49 -action_193 (55#) = happyShift action_50 -action_193 (56#) = happyShift action_51 -action_193 (57#) = happyShift action_52 -action_193 (58#) = happyShift action_53 -action_193 (59#) = happyShift action_54 -action_193 x = happyTcHack x happyReduce_11 - -action_194 (41#) = happyShift action_36 -action_194 (42#) = happyShift action_37 -action_194 (43#) = happyShift action_38 -action_194 (44#) = happyShift action_39 -action_194 (45#) = happyShift action_40 -action_194 (46#) = happyShift action_41 -action_194 (47#) = happyShift action_42 -action_194 (48#) = happyShift action_43 -action_194 (49#) = happyShift action_44 -action_194 (50#) = happyShift action_45 -action_194 (51#) = happyShift action_46 -action_194 (52#) = happyShift action_47 -action_194 (53#) = happyShift action_48 -action_194 (54#) = happyShift action_49 -action_194 (55#) = happyShift action_50 -action_194 (56#) = happyShift action_51 -action_194 (57#) = happyShift action_52 -action_194 (58#) = happyShift action_53 -action_194 (59#) = happyShift action_54 -action_194 (79#) = happyShift action_199 -action_194 x = happyTcHack x happyReduce_48 - -action_195 x = happyTcHack x happyReduce_72 - -action_196 x = happyTcHack x happyReduce_63 - -action_197 (41#) = happyShift action_36 -action_197 (42#) = happyShift action_37 -action_197 (43#) = happyShift action_38 -action_197 (44#) = happyShift action_39 -action_197 (45#) = happyShift action_40 -action_197 (46#) = happyShift action_41 -action_197 (47#) = happyShift action_42 -action_197 (48#) = happyShift action_43 -action_197 (49#) = happyShift action_44 -action_197 (50#) = happyShift action_45 -action_197 (51#) = happyShift action_46 -action_197 (52#) = happyShift action_47 -action_197 (53#) = happyShift action_48 -action_197 (54#) = happyShift action_49 -action_197 (55#) = happyShift action_50 -action_197 (56#) = happyShift action_51 -action_197 (57#) = happyShift action_52 -action_197 (58#) = happyShift action_53 -action_197 (59#) = happyShift action_54 -action_197 (67#) = happyShift action_168 -action_197 (68#) = happyShift action_169 -action_197 (15#) = happyGoto action_198 -action_197 x = happyTcHack x happyReduce_60 - -action_198 x = happyTcHack x happyReduce_57 - -action_199 (83#) = happyShift action_28 -action_199 (6#) = happyGoto action_208 -action_199 x = happyTcHack x happyFail - -action_200 (40#) = happyShift action_207 -action_200 (41#) = happyShift action_36 -action_200 (42#) = happyShift action_37 -action_200 (43#) = happyShift action_38 -action_200 (44#) = happyShift action_39 -action_200 (45#) = happyShift action_40 -action_200 (46#) = happyShift action_41 -action_200 (47#) = happyShift action_42 -action_200 (48#) = happyShift action_43 -action_200 (49#) = happyShift action_44 -action_200 (50#) = happyShift action_45 -action_200 (51#) = happyShift action_46 -action_200 (52#) = happyShift action_47 -action_200 (53#) = happyShift action_48 -action_200 (54#) = happyShift action_49 -action_200 (55#) = happyShift action_50 -action_200 (56#) = happyShift action_51 -action_200 (57#) = happyShift action_52 -action_200 (58#) = happyShift action_53 -action_200 (59#) = happyShift action_54 -action_200 x = happyTcHack x happyFail - -action_201 x = happyTcHack x happyReduce_77 - -action_202 x = happyTcHack x happyReduce_6 - -action_203 (28#) = happyShift action_12 -action_203 (29#) = happyShift action_13 -action_203 (30#) = happyShift action_14 -action_203 (35#) = happyShift action_15 -action_203 (42#) = happyShift action_16 -action_203 (43#) = happyShift action_17 -action_203 (44#) = happyShift action_18 -action_203 (50#) = happyShift action_19 -action_203 (56#) = happyShift action_20 -action_203 (60#) = happyShift action_21 -action_203 (61#) = happyShift action_22 -action_203 (69#) = happyShift action_23 -action_203 (70#) = happyShift action_24 -action_203 (74#) = happyShift action_25 -action_203 (76#) = happyShift action_26 -action_203 (81#) = happyShift action_27 -action_203 (83#) = happyShift action_28 -action_203 (85#) = happyShift action_29 -action_203 (86#) = happyShift action_30 -action_203 (87#) = happyShift action_31 -action_203 (6#) = happyGoto action_2 -action_203 (7#) = happyGoto action_206 -action_203 (9#) = happyGoto action_4 -action_203 (16#) = happyGoto action_5 -action_203 (17#) = happyGoto action_6 -action_203 (18#) = happyGoto action_7 -action_203 (21#) = happyGoto action_8 -action_203 (24#) = happyGoto action_9 -action_203 (25#) = happyGoto action_10 -action_203 (26#) = happyGoto action_11 -action_203 x = happyTcHack x happyFail - -action_204 (41#) = happyShift action_36 -action_204 (42#) = happyShift action_37 -action_204 (43#) = happyShift action_38 -action_204 (44#) = happyShift action_39 -action_204 (45#) = happyShift action_40 -action_204 (46#) = happyShift action_41 -action_204 (47#) = happyShift action_42 -action_204 (48#) = happyShift action_43 -action_204 (49#) = happyShift action_44 -action_204 (50#) = happyShift action_45 -action_204 (51#) = happyShift action_46 -action_204 (52#) = happyShift action_47 -action_204 (53#) = happyShift action_48 -action_204 (54#) = happyShift action_49 -action_204 (55#) = happyShift action_50 -action_204 (56#) = happyShift action_51 -action_204 (57#) = happyShift action_52 -action_204 (58#) = happyShift action_53 -action_204 (59#) = happyShift action_54 -action_204 (82#) = happyShift action_205 -action_204 x = happyTcHack x happyFail - -action_205 (28#) = happyShift action_12 -action_205 (29#) = happyShift action_13 -action_205 (30#) = happyShift action_14 -action_205 (35#) = happyShift action_15 -action_205 (42#) = happyShift action_16 -action_205 (43#) = happyShift action_17 -action_205 (44#) = happyShift action_18 -action_205 (50#) = happyShift action_19 -action_205 (56#) = happyShift action_20 -action_205 (60#) = happyShift action_21 -action_205 (61#) = happyShift action_22 -action_205 (69#) = happyShift action_23 -action_205 (70#) = happyShift action_24 -action_205 (74#) = happyShift action_25 -action_205 (76#) = happyShift action_26 -action_205 (77#) = happyShift action_34 -action_205 (81#) = happyShift action_27 -action_205 (83#) = happyShift action_28 -action_205 (85#) = happyShift action_29 -action_205 (86#) = happyShift action_30 -action_205 (87#) = happyShift action_31 -action_205 (4#) = happyGoto action_210 -action_205 (6#) = happyGoto action_2 -action_205 (7#) = happyGoto action_33 -action_205 (9#) = happyGoto action_4 -action_205 (16#) = happyGoto action_5 -action_205 (17#) = happyGoto action_6 -action_205 (18#) = happyGoto action_7 -action_205 (21#) = happyGoto action_8 -action_205 (24#) = happyGoto action_9 -action_205 (25#) = happyGoto action_10 -action_205 (26#) = happyGoto action_11 -action_205 x = happyTcHack x happyFail - -action_206 (41#) = happyShift action_36 -action_206 (42#) = happyShift action_37 -action_206 (43#) = happyShift action_38 -action_206 (44#) = happyShift action_39 -action_206 (45#) = happyShift action_40 -action_206 (46#) = happyShift action_41 -action_206 (47#) = happyShift action_42 -action_206 (48#) = happyShift action_43 -action_206 (49#) = happyShift action_44 -action_206 (50#) = happyShift action_45 -action_206 (51#) = happyShift action_46 -action_206 (52#) = happyShift action_47 -action_206 (53#) = happyShift action_48 -action_206 (54#) = happyShift action_49 -action_206 (55#) = happyShift action_50 -action_206 (56#) = happyShift action_51 -action_206 (57#) = happyShift action_52 -action_206 (58#) = happyShift action_53 -action_206 (59#) = happyShift action_54 -action_206 (82#) = happyShift action_209 -action_206 x = happyTcHack x happyFail - -action_207 x = happyTcHack x happyReduce_79 - -action_208 x = happyTcHack x happyReduce_49 - -action_209 (28#) = happyShift action_12 -action_209 (29#) = happyShift action_13 -action_209 (30#) = happyShift action_14 -action_209 (35#) = happyShift action_15 -action_209 (42#) = happyShift action_16 -action_209 (43#) = happyShift action_17 -action_209 (44#) = happyShift action_18 -action_209 (50#) = happyShift action_19 -action_209 (56#) = happyShift action_20 -action_209 (60#) = happyShift action_21 -action_209 (61#) = happyShift action_22 -action_209 (69#) = happyShift action_23 -action_209 (70#) = happyShift action_24 -action_209 (74#) = happyShift action_25 -action_209 (76#) = happyShift action_26 -action_209 (77#) = happyShift action_34 -action_209 (81#) = happyShift action_27 -action_209 (83#) = happyShift action_28 -action_209 (85#) = happyShift action_29 -action_209 (86#) = happyShift action_30 -action_209 (87#) = happyShift action_31 -action_209 (4#) = happyGoto action_211 -action_209 (6#) = happyGoto action_2 -action_209 (7#) = happyGoto action_33 -action_209 (9#) = happyGoto action_4 -action_209 (16#) = happyGoto action_5 -action_209 (17#) = happyGoto action_6 -action_209 (18#) = happyGoto action_7 -action_209 (21#) = happyGoto action_8 -action_209 (24#) = happyGoto action_9 -action_209 (25#) = happyGoto action_10 -action_209 (26#) = happyGoto action_11 -action_209 x = happyTcHack x happyFail - -action_210 x = happyTcHack x happyReduce_4 - -action_211 x = happyTcHack x happyReduce_3 - -happyReduce_1 = happySpecReduce_1 4# happyReduction_1 -happyReduction_1 happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - happyIn4 - ([happy_var_1] - )} - -happyReduce_2 = happySpecReduce_2 4# happyReduction_2 -happyReduction_2 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - happyIn4 - ([happy_var_1] - )} - -happyReduce_3 = happyReduce 10# 4# happyReduction_3 -happyReduction_3 (happy_x_10 `HappyStk` - happy_x_9 `HappyStk` - happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - case happyOut5 happy_x_5 of { happy_var_5 -> - case happyOut7 happy_x_8 of { happy_var_8 -> - case happyOut4 happy_x_10 of { happy_var_10 -> - happyIn4 - ((Ast "define" ([Avar happy_var_3,happy_var_8]++happy_var_5)):happy_var_10 - ) `HappyStk` happyRest}}}} - -happyReduce_4 = happyReduce 9# 4# happyReduction_4 -happyReduction_4 (happy_x_9 `HappyStk` - happy_x_8 `HappyStk` - happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - case happyOut7 happy_x_7 of { happy_var_7 -> - case happyOut4 happy_x_9 of { happy_var_9 -> - happyIn4 - ((Ast "define" ([Avar happy_var_3,happy_var_7])):happy_var_9 - ) `HappyStk` happyRest}}} - -happyReduce_5 = happySpecReduce_1 5# happyReduction_5 -happyReduction_5 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn5 - ([happy_var_1] - )} - -happyReduce_6 = happySpecReduce_3 5# happyReduction_6 -happyReduction_6 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut5 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - happyIn5 - (happy_var_1++[happy_var_3] - )}} - -happyReduce_7 = happySpecReduce_1 6# happyReduction_7 -happyReduction_7 happy_x_1 - = case happyOutTok happy_x_1 of { (Variable happy_var_1) -> - happyIn6 - (Avar happy_var_1 - )} - -happyReduce_8 = happyReduce 5# 7# happyReduction_8 -happyReduction_8 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut12 happy_x_2 of { happy_var_2 -> - case happyOut13 happy_x_3 of { happy_var_3 -> - case happyOut7 happy_x_5 of { happy_var_5 -> - happyIn7 - ((snd happy_var_3) (happy_var_1 (happy_var_2 ((fst happy_var_3) happy_var_5))) - ) `HappyStk` happyRest}}}} - -happyReduce_9 = happyReduce 4# 7# happyReduction_9 -happyReduction_9 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut10 happy_x_2 of { happy_var_2 -> - case happyOut7 happy_x_4 of { happy_var_4 -> - happyIn7 - (call "some" [happy_var_2 happy_var_4] - ) `HappyStk` happyRest}} - -happyReduce_10 = happyReduce 4# 7# happyReduction_10 -happyReduction_10 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut10 happy_x_2 of { happy_var_2 -> - case happyOut7 happy_x_4 of { happy_var_4 -> - happyIn7 - (call "not" [call "some" [happy_var_2 (call "not" [happy_var_4])]] - ) `HappyStk` happyRest}} - -happyReduce_11 = happyReduce 6# 7# happyReduction_11 -happyReduction_11 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut7 happy_x_2 of { happy_var_2 -> - case happyOut7 happy_x_4 of { happy_var_4 -> - case happyOut7 happy_x_6 of { happy_var_6 -> - happyIn7 - (call "if" [happy_var_2,happy_var_4,happy_var_6] - ) `HappyStk` happyRest}}} - -happyReduce_12 = happySpecReduce_1 7# happyReduction_12 -happyReduction_12 happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn7 - (happy_var_1 - )} - -happyReduce_13 = happySpecReduce_1 7# happyReduction_13 -happyReduction_13 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn7 - (happy_var_1 - )} - -happyReduce_14 = happySpecReduce_1 7# happyReduction_14 -happyReduction_14 happy_x_1 - = case happyOut16 happy_x_1 of { happy_var_1 -> - happyIn7 - (happy_var_1 - )} - -happyReduce_15 = happySpecReduce_3 7# happyReduction_15 -happyReduction_15 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "to" [happy_var_1,happy_var_3] - )}} - -happyReduce_16 = happySpecReduce_3 7# happyReduction_16 -happyReduction_16 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "+" [happy_var_1,happy_var_3] - )}} - -happyReduce_17 = happySpecReduce_3 7# happyReduction_17 -happyReduction_17 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "-" [happy_var_1,happy_var_3] - )}} - -happyReduce_18 = happySpecReduce_3 7# happyReduction_18 -happyReduction_18 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "*" [happy_var_1,happy_var_3] - )}} - -happyReduce_19 = happySpecReduce_3 7# happyReduction_19 -happyReduction_19 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "div" [happy_var_1,happy_var_3] - )}} - -happyReduce_20 = happySpecReduce_3 7# happyReduction_20 -happyReduction_20 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "idiv" [happy_var_1,happy_var_3] - )}} - -happyReduce_21 = happySpecReduce_3 7# happyReduction_21 -happyReduction_21 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "mod" [happy_var_1,happy_var_3] - )}} - -happyReduce_22 = happySpecReduce_3 7# happyReduction_22 -happyReduction_22 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "=" [happy_var_1,happy_var_3] - )}} - -happyReduce_23 = happySpecReduce_3 7# happyReduction_23 -happyReduction_23 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "!=" [happy_var_1,happy_var_3] - )}} - -happyReduce_24 = happySpecReduce_3 7# happyReduction_24 -happyReduction_24 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "<" [happy_var_1,happy_var_3] - )}} - -happyReduce_25 = happySpecReduce_3 7# happyReduction_25 -happyReduction_25 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "<=" [happy_var_1,happy_var_3] - )}} - -happyReduce_26 = happySpecReduce_3 7# happyReduction_26 -happyReduction_26 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call ">" [happy_var_1,happy_var_3] - )}} - -happyReduce_27 = happySpecReduce_3 7# happyReduction_27 -happyReduction_27 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call ">=" [happy_var_1,happy_var_3] - )}} - -happyReduce_28 = happySpecReduce_3 7# happyReduction_28 -happyReduction_28 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "and" [happy_var_1,happy_var_3] - )}} - -happyReduce_29 = happySpecReduce_3 7# happyReduction_29 -happyReduction_29 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "or" [happy_var_1,happy_var_3] - )}} - -happyReduce_30 = happySpecReduce_3 7# happyReduction_30 -happyReduction_30 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "not" [happy_var_1,happy_var_3] - )}} - -happyReduce_31 = happySpecReduce_3 7# happyReduction_31 -happyReduction_31 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "union" [happy_var_1,happy_var_3] - )}} - -happyReduce_32 = happySpecReduce_3 7# happyReduction_32 -happyReduction_32 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "itersect" [happy_var_1,happy_var_3] - )}} - -happyReduce_33 = happySpecReduce_3 7# happyReduction_33 -happyReduction_33 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (call "except" [happy_var_1,happy_var_3] - )}} - -happyReduce_34 = happySpecReduce_2 7# happyReduction_34 -happyReduction_34 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn7 - (call "uplus" [happy_var_2] - )} - -happyReduce_35 = happySpecReduce_2 7# happyReduction_35 -happyReduction_35 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn7 - (call "uminus" [happy_var_2] - )} - -happyReduce_36 = happySpecReduce_2 7# happyReduction_36 -happyReduction_36 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn7 - (call "not" [happy_var_2] - )} - -happyReduce_37 = happySpecReduce_1 7# happyReduction_37 -happyReduction_37 happy_x_1 - = case happyOutTok happy_x_1 of { (TString happy_var_1) -> - happyIn7 - (Astring happy_var_1 - )} - -happyReduce_38 = happySpecReduce_1 7# happyReduction_38 -happyReduction_38 happy_x_1 - = case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> - happyIn7 - (Aint happy_var_1 - )} - -happyReduce_39 = happySpecReduce_1 7# happyReduction_39 -happyReduction_39 happy_x_1 - = case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> - happyIn7 - (Afloat happy_var_1 - )} - -happyReduce_40 = happySpecReduce_1 8# happyReduction_40 -happyReduction_40 happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - happyIn8 - ([happy_var_1] - )} - -happyReduce_41 = happySpecReduce_3 8# happyReduction_41 -happyReduction_41 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn8 - (happy_var_1++[happy_var_3] - )}} - -happyReduce_42 = happySpecReduce_2 9# happyReduction_42 -happyReduction_42 happy_x_2 - happy_x_1 - = case happyOut10 happy_x_2 of { happy_var_2 -> - happyIn9 - (happy_var_2 - )} - -happyReduce_43 = happySpecReduce_2 9# happyReduction_43 -happyReduction_43 happy_x_2 - happy_x_1 - = case happyOut11 happy_x_2 of { happy_var_2 -> - happyIn9 - (happy_var_2 - )} - -happyReduce_44 = happySpecReduce_3 9# happyReduction_44 -happyReduction_44 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut10 happy_x_3 of { happy_var_3 -> - happyIn9 - (happy_var_1 . happy_var_3 - )}} - -happyReduce_45 = happySpecReduce_3 9# happyReduction_45 -happyReduction_45 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut9 happy_x_1 of { happy_var_1 -> - case happyOut11 happy_x_3 of { happy_var_3 -> - happyIn9 - (happy_var_1 . happy_var_3 - )}} - -happyReduce_46 = happySpecReduce_3 10# happyReduction_46 -happyReduction_46 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn10 - (\x -> Ast "for" [happy_var_1,Avar "$",happy_var_3,x] - )}} - -happyReduce_47 = happyReduce 5# 10# happyReduction_47 -happyReduction_47 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut6 happy_x_5 of { happy_var_5 -> - happyIn10 - (\x -> Ast "for" [happy_var_1,happy_var_5,happy_var_3,x] - ) `HappyStk` happyRest}}} - -happyReduce_48 = happyReduce 5# 10# happyReduction_48 -happyReduction_48 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut7 happy_x_5 of { happy_var_5 -> - happyIn10 - (\x -> happy_var_1(Ast "for" [happy_var_3,Avar "$",happy_var_5,x]) - ) `HappyStk` happyRest}}} - -happyReduce_49 = happyReduce 7# 10# happyReduction_49 -happyReduction_49 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut10 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut7 happy_x_5 of { happy_var_5 -> - case happyOut6 happy_x_7 of { happy_var_7 -> - happyIn10 - (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_7,happy_var_5,x]) - ) `HappyStk` happyRest}}}} - -happyReduce_50 = happySpecReduce_3 11# happyReduction_50 -happyReduction_50 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn11 - (\x -> Ast "let" [happy_var_1,happy_var_3,x] - )}} - -happyReduce_51 = happyReduce 5# 11# happyReduction_51 -happyReduction_51 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut11 happy_x_1 of { happy_var_1 -> - case happyOut6 happy_x_3 of { happy_var_3 -> - case happyOut7 happy_x_5 of { happy_var_5 -> - happyIn11 - (\x -> happy_var_1(Ast "let" [happy_var_3,happy_var_5,x]) - ) `HappyStk` happyRest}}} - -happyReduce_52 = happySpecReduce_2 12# happyReduction_52 -happyReduction_52 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn12 - (\x -> Ast "predicate" [happy_var_2,x] - )} - -happyReduce_53 = happySpecReduce_0 12# happyReduction_53 -happyReduction_53 = happyIn12 - (id - ) - -happyReduce_54 = happySpecReduce_2 13# happyReduction_54 -happyReduction_54 happy_x_2 - happy_x_1 - = case happyOut14 happy_x_2 of { happy_var_2 -> - happyIn13 - ((\x -> Ast "sortTuple" (x:(fst happy_var_2)), - \x -> Ast "sort" (x:(snd happy_var_2))) - )} - -happyReduce_55 = happySpecReduce_0 13# happyReduction_55 -happyReduction_55 = happyIn13 - ((id,id) - ) - -happyReduce_56 = happySpecReduce_2 14# happyReduction_56 -happyReduction_56 happy_x_2 - happy_x_1 - = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut15 happy_x_2 of { happy_var_2 -> - happyIn14 - (([happy_var_1],[happy_var_2]) - )}} - -happyReduce_57 = happyReduce 4# 14# happyReduction_57 -happyReduction_57 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut14 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - case happyOut15 happy_x_4 of { happy_var_4 -> - happyIn14 - (((fst happy_var_1)++[happy_var_3],(snd happy_var_1)++[happy_var_4]) - ) `HappyStk` happyRest}}} - -happyReduce_58 = happySpecReduce_1 15# happyReduction_58 -happyReduction_58 happy_x_1 - = happyIn15 - (Avar "ascending" - ) - -happyReduce_59 = happySpecReduce_1 15# happyReduction_59 -happyReduction_59 happy_x_1 - = happyIn15 - (Avar "descending" - ) - -happyReduce_60 = happySpecReduce_0 15# happyReduction_60 -happyReduction_60 = happyIn15 - (Avar "ascending" - ) - -happyReduce_61 = happyReduce 4# 16# happyReduction_61 -happyReduction_61 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - happyIn16 - (call "element" [Avar happy_var_3] - ) `HappyStk` happyRest} - -happyReduce_62 = happyReduce 4# 16# happyReduction_62 -happyReduction_62 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (QName happy_var_3) -> - happyIn16 - (call "attribute" [Avar happy_var_3] - ) `HappyStk` happyRest} - -happyReduce_63 = happyReduce 6# 17# happyReduction_63 -happyReduction_63 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_5 of { (QName happy_var_5) -> - happyIn17 - (if head happy_var_1 == Astring happy_var_5 - then Ast "construction" (happy_var_1++[concatAll happy_var_3]) - else error("Unmatched tags in element construction: "++happy_var_5) - ) `HappyStk` happyRest}}} - -happyReduce_64 = happyReduce 5# 17# happyReduction_64 -happyReduction_64 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_4 of { (QName happy_var_4) -> - happyIn17 - (if head happy_var_1 == Astring happy_var_4 - then Ast "construction" (happy_var_1++[call "empty" []]) - else error("Unmatched tags in element construction: "++happy_var_4) - ) `HappyStk` happyRest}} - -happyReduce_65 = happySpecReduce_2 17# happyReduction_65 -happyReduction_65 happy_x_2 - happy_x_1 - = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn17 - (Ast "construction" (happy_var_1++[call "empty" []]) - )} - -happyReduce_66 = happySpecReduce_2 18# happyReduction_66 -happyReduction_66 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (QName happy_var_2) -> - happyIn18 - ([Astring happy_var_2,Ast "attributes" []] - )} - -happyReduce_67 = happySpecReduce_3 18# happyReduction_67 -happyReduction_67 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn18 - ([Astring happy_var_2,Ast "attributes" happy_var_3] - )}} - -happyReduce_68 = happySpecReduce_3 19# happyReduction_68 -happyReduction_68 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn19 - (happy_var_2 - )} - -happyReduce_69 = happySpecReduce_1 19# happyReduction_69 -happyReduction_69 happy_x_1 - = case happyOutTok happy_x_1 of { (TString happy_var_1) -> - happyIn19 - ([Astring happy_var_1] - )} - -happyReduce_70 = happySpecReduce_1 19# happyReduction_70 -happyReduction_70 happy_x_1 - = case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> - happyIn19 - ([Astring happy_var_1] - )} - -happyReduce_71 = happySpecReduce_1 19# happyReduction_71 -happyReduction_71 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn19 - ([happy_var_1] - )} - -happyReduce_72 = happyReduce 4# 19# happyReduction_72 -happyReduction_72 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut8 happy_x_3 of { happy_var_3 -> - happyIn19 - (happy_var_1++happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_73 = happySpecReduce_2 19# happyReduction_73 -happyReduction_73 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TString happy_var_2) -> - happyIn19 - (happy_var_1++[Astring happy_var_2] - )}} - -happyReduce_74 = happySpecReduce_2 19# happyReduction_74 -happyReduction_74 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (XMLtext happy_var_2) -> - happyIn19 - (happy_var_1++[Astring happy_var_2] - )}} - -happyReduce_75 = happySpecReduce_2 19# happyReduction_75 -happyReduction_75 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut17 happy_x_2 of { happy_var_2 -> - happyIn19 - (happy_var_1++[happy_var_2] - )}} - -happyReduce_76 = happySpecReduce_3 20# happyReduction_76 -happyReduction_76 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOutTok happy_x_3 of { (TString happy_var_3) -> - happyIn20 - ([Ast "pair" [Astring happy_var_1,Astring happy_var_3]] - )}} - -happyReduce_77 = happyReduce 5# 20# happyReduction_77 -happyReduction_77 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOut7 happy_x_4 of { happy_var_4 -> - happyIn20 - ([Ast "pair" [Astring happy_var_1,happy_var_4]] - ) `HappyStk` happyRest}} - -happyReduce_78 = happyReduce 4# 20# happyReduction_78 -happyReduction_78 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOutTok happy_x_4 of { (TString happy_var_4) -> - happyIn20 - ((Ast "pair" [Astring happy_var_2,Astring happy_var_4]):happy_var_1 - ) `HappyStk` happyRest}}} - -happyReduce_79 = happyReduce 6# 20# happyReduction_79 -happyReduction_79 (happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (QName happy_var_2) -> - case happyOut7 happy_x_5 of { happy_var_5 -> - happyIn20 - ((Ast "pair" [Astring happy_var_2,happy_var_5]):happy_var_1 - ) `HappyStk` happyRest}}} - -happyReduce_80 = happySpecReduce_1 21# happyReduction_80 -happyReduction_80 happy_x_1 - = case happyOut24 happy_x_1 of { happy_var_1 -> - happyIn21 - (happy_var_1 "child" (Avar ".") - )} - -happyReduce_81 = happySpecReduce_2 21# happyReduction_81 -happyReduction_81 happy_x_2 - happy_x_1 - = case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn21 - (happy_var_2 "attribute" (Avar ".") - )} - -happyReduce_82 = happySpecReduce_2 21# happyReduction_82 -happyReduction_82 happy_x_2 - happy_x_1 - = case happyOut24 happy_x_1 of { happy_var_1 -> - case happyOut22 happy_x_2 of { happy_var_2 -> - happyIn21 - (happy_var_2(happy_var_1 "child" (Avar ".")) - )}} - -happyReduce_83 = happySpecReduce_3 21# happyReduction_83 -happyReduction_83 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut24 happy_x_2 of { happy_var_2 -> - case happyOut22 happy_x_3 of { happy_var_3 -> - happyIn21 - (happy_var_3(happy_var_2 "attribute" (Avar ".")) - )}} - -happyReduce_84 = happySpecReduce_1 22# happyReduction_84 -happyReduction_84 happy_x_1 - = case happyOut23 happy_x_1 of { happy_var_1 -> - happyIn22 - (happy_var_1 - )} - -happyReduce_85 = happySpecReduce_2 22# happyReduction_85 -happyReduction_85 happy_x_2 - happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn22 - (happy_var_2 . happy_var_1 - )}} - -happyReduce_86 = happySpecReduce_2 23# happyReduction_86 -happyReduction_86 happy_x_2 - happy_x_1 - = case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn23 - (\e -> happy_var_2 "child" e - )} - -happyReduce_87 = happySpecReduce_3 23# happyReduction_87 -happyReduction_87 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn23 - (\e -> happy_var_3 "attribute" e - )} - -happyReduce_88 = happySpecReduce_3 23# happyReduction_88 -happyReduction_88 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn23 - (\e -> happy_var_3 "descendant" e - )} - -happyReduce_89 = happyReduce 4# 23# happyReduction_89 -happyReduction_89 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut24 happy_x_4 of { happy_var_4 -> - happyIn23 - (\e -> happy_var_4 "descendant_attribute" e - ) `HappyStk` happyRest} - -happyReduce_90 = happySpecReduce_2 23# happyReduction_90 -happyReduction_90 happy_x_2 - happy_x_1 - = happyIn23 - (\e -> call "parent" [e] - ) - -happyReduce_91 = happySpecReduce_1 24# happyReduction_91 -happyReduction_91 happy_x_1 - = case happyOut25 happy_x_1 of { happy_var_1 -> - happyIn24 - (happy_var_1 - )} - -happyReduce_92 = happyReduce 4# 24# happyReduction_92 -happyReduction_92 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut24 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn24 - (\t e -> Ast "predicate" [happy_var_3,happy_var_1 t e] - ) `HappyStk` happyRest}} - -happyReduce_93 = happySpecReduce_1 25# happyReduction_93 -happyReduction_93 happy_x_1 - = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn25 - (\t e -> happy_var_1 t e - )} - -happyReduce_94 = happySpecReduce_1 25# happyReduction_94 -happyReduction_94 happy_x_1 - = happyIn25 - (\t e -> call t [Astring "*",e] - ) - -happyReduce_95 = happySpecReduce_1 25# happyReduction_95 -happyReduction_95 happy_x_1 - = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - happyIn25 - (\t e -> call t [Astring happy_var_1,e] - )} - -happyReduce_96 = happySpecReduce_1 26# happyReduction_96 -happyReduction_96 happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - happyIn26 - (\_ _ -> happy_var_1 - )} - -happyReduce_97 = happySpecReduce_1 26# happyReduction_97 -happyReduction_97 happy_x_1 - = happyIn26 - (\_ e -> e - ) - -happyReduce_98 = happySpecReduce_3 26# happyReduction_98 -happyReduction_98 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn26 - (\_ _ -> concatAll happy_var_2 - )} - -happyReduce_99 = happySpecReduce_2 26# happyReduction_99 -happyReduction_99 happy_x_2 - happy_x_1 - = happyIn26 - (\_ _ -> call "empty" [] - ) - -happyReduce_100 = happyReduce 4# 26# happyReduction_100 -happyReduction_100 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - case happyOut8 happy_x_3 of { happy_var_3 -> - happyIn26 - (\_ _ -> call happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_101 = happySpecReduce_3 26# happyReduction_101 -happyReduction_101 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (QName happy_var_1) -> - happyIn26 - (if elem happy_var_1 ["text"] - then \_ e -> call happy_var_1 [e] - else \_ _ -> call happy_var_1 [] - )} - -happyNewToken action sts stk [] = - action 88# 88# notHappyAtAll (HappyState action) sts stk [] - -happyNewToken action sts stk (tk:tks) = - let cont i = action i i tk (HappyState action) sts stk tks in - case tk of { - RETURN -> cont 27#; - SOME -> cont 28#; - EVERY -> cont 29#; - IF -> cont 30#; - THEN -> cont 31#; - ELSE -> cont 32#; - LB -> cont 33#; - RB -> cont 34#; - LP -> cont 35#; - RP -> cont 36#; - LSB -> cont 37#; - RSB -> cont 38#; - LESCAPE -> cont 39#; - RESCAPE -> cont 40#; - TO -> cont 41#; - PLUS -> cont 42#; - MINUS -> cont 43#; - TIMES -> cont 44#; - DIV -> cont 45#; - IDIV -> cont 46#; - MOD -> cont 47#; - TEQ -> cont 48#; - TNEQ -> cont 49#; - TLT -> cont 50#; - LEQ -> cont 51#; - TGT -> cont 52#; - GEQ -> cont 53#; - AND -> cont 54#; - OR -> cont 55#; - NOT -> cont 56#; - UNION -> cont 57#; - INTERSECT -> cont 58#; - EXCEPT -> cont 59#; - FOR -> cont 60#; - LET -> cont 61#; - IN -> cont 62#; - COMMA -> cont 63#; - ASSIGN -> cont 64#; - WHERE -> cont 65#; - ORDERBY -> cont 66#; - ASCENDING -> cont 67#; - DESCENDING -> cont 68#; - ELEMENT -> cont 69#; - ATTRIBUTE -> cont 70#; - STAG -> cont 71#; - ETAG -> cont 72#; - SATISFIES -> cont 73#; - ATSIGN -> cont 74#; - SLASH -> cont 75#; - QName happy_dollar_dollar -> cont 76#; - DEFINE -> cont 77#; - FUNCTION -> cont 78#; - AT -> cont 79#; - DOTS -> cont 80#; - DOT -> cont 81#; - SEMI -> cont 82#; - Variable happy_dollar_dollar -> cont 83#; - XMLtext happy_dollar_dollar -> cont 84#; - TInteger happy_dollar_dollar -> cont 85#; - TFloat happy_dollar_dollar -> cont 86#; - TString happy_dollar_dollar -> cont 87#; - _ -> happyError' (tk:tks) - } - -happyError_ tk tks = happyError' (tk:tks) - -newtype HappyIdentity a = HappyIdentity a -happyIdentity = HappyIdentity -happyRunIdentity (HappyIdentity a) = a - -instance Monad HappyIdentity where - return = HappyIdentity - (HappyIdentity p) >>= q = q p - -happyThen :: () => HappyIdentity a -> (a -> HappyIdentity b) -> HappyIdentity b -happyThen = (>>=) -happyReturn :: () => a -> HappyIdentity a -happyReturn = (return) -happyThen1 m k tks = (>>=) m (\a -> k a tks) -happyReturn1 :: () => a -> b -> HappyIdentity a -happyReturn1 = \a tks -> (return) a -happyError' :: () => [Token] -> HappyIdentity a -happyError' = HappyIdentity . parseError - -parse tks = happyRunIdentity happySomeParser where - happySomeParser = happyThen (happyParse action_0 tks) (\x -> happyReturn (happyOut4 x)) - -happySeq = happyDontSeq - - --- Abstract Syntax Tree for XQueries -data Ast = Ast String [Ast] - | Avar String - | Aint Int - | Afloat Float - | Astring String - deriving Eq - - -instance Show Ast - where show (Ast s []) = s ++ "()" - show (Ast s (x:xs)) = s ++ "(" ++ (show x) - ++ (foldr (\a r -> ","++(show a)++r) "" xs) - ++ ")" - show (Avar s) = s - show (Aint n) = show n - show (Afloat n) = show n - show (Astring s) = "\'" ++ s ++ "\'" - - -call :: String -> [Ast] -> Ast -call name args = Ast "call" ((Avar name):args) - - -concatAll :: [Ast] -> Ast -concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs -concatAll _ = call "empty" [] - - -parseError tk = error ("Parse error: "++(show (take 10 tk))) - - -data Token - = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB - | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD - | TEQ | TNEQ | TLT | LEQ | TGT | GEQ | AND | OR | NOT | UNION | INTERSECT - | EXCEPT | FOR | LET | IN | COMMA | ASSIGN | WHERE | ORDERBY | ASCENDING - | DESCENDING | ELEMENT | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN - | SLASH | DEFINE | FUNCTION | AT | SEMI | DOT | DOTS | TokenEOF - | QName String | Variable String | XMLtext String | TInteger Int - | TFloat Float | TString String - deriving Show - - -scan :: String -> [Token] -scan cs = lexer cs [0] - - -xmlText "" = [] -xmlText text = [XMLtext text] - --- scans XML PCDATA and returns an XMLtext token with the PCData text -xml :: String -> String -> [Int] -> [Token] -xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n)) -xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n) -xml ('<':cs) text (k:n) = (xmlText text)++(TLT : lexer cs (k+2:n)) -xml ('\'':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n) -xml (c:cs) text n = xml cs (text++[c]) n -xml [] text _ = xmlText text - - -isQN c = elem c "_:-" || isDigit c || isAlpha c - -isVar c = elem c "_" || isDigit c || isAlpha c - --- the XQuery scanner -lexer :: String -> [Int] -> [Token] -lexer [] [0] = [] -lexer [] _ = error("Unbalanced tags") -lexer (' ':'>':' ':cs) n = TGT : lexer cs n -lexer (c:cs) n - | isSpace c = lexer cs n - | isAlpha c = lexVar (c:cs) n - | isDigit c = lexNum (c:cs) n -lexer ('$':c:cs) n | isAlpha c - = let (var,rest) = span isVar (c:cs) - in (Variable var) : lexer rest n -lexer ('\'':'{':cs) n = LESCAPE : lexer cs n -lexer (':':'=':cs) n = ASSIGN : lexer cs n -lexer ('<':'/':cs) n = STAG : lexer cs n -lexer ('<':'=':cs) n = LEQ : lexer cs n -lexer ('>':'=':cs) n = GEQ : lexer cs n -lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n) -lexer ('.':'.':cs) n = DOTS : lexer cs n -lexer ('.':cs) n = DOT : lexer cs n -lexer ('}':'\'':cs) n = RESCAPE : lexer cs n -lexer ('!':'=':cs) n = TNEQ : lexer cs n -lexer ('\'':cs) n = lexString cs n -lexer ('[':cs) n = LB : lexer cs n -lexer (']':cs) n = RB : lexer cs n -lexer ('(':cs) n = LP : lexer cs n -lexer (')':cs) n = RP : lexer cs n -lexer ('}':cs) (_:n) = RSB : xml cs "" n -lexer ('+':cs) n = PLUS : lexer cs n -lexer ('-':cs) n = MINUS : lexer cs n -lexer ('*':cs) n = TIMES : lexer cs n -lexer ('=':cs) n = TEQ : lexer cs n -lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n -lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n) -lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (k-1:n) else xml cs "" (k-1:n)) -lexer (',':cs) n = COMMA : lexer cs n -lexer ('@':cs) n = ATSIGN : lexer cs n -lexer ('/':cs) n = SLASH : lexer cs n -lexer ('{':cs) n = LSB : lexer cs n -lexer (';':cs) n = SEMI : lexer cs n -lexer (c:cs) n = error ("illegal character "++[c]) - -lexNum cs n = if null rest || head rest /= '.' - 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 /= '\'' - -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 - ("orderby",rest) -> ORDERBY : 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 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} --- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp - -{-# LINE 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" #-} +-- 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 "" #-} +{-# LINE 1 "" #-} +{-# 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" #-} {-# NOINLINE happyShift #-} {-# NOINLINE happySpecReduce_0 #-} {-# NOINLINE happySpecReduce_1 #-} diff --git a/XQueryParser.y b/XQueryParser.y --- a/XQueryParser.y +++ b/XQueryParser.y @@ -4,7 +4,7 @@ - Programmer: Leonidas Fegaras - Email: fegaras@cse.uta.edu - Web: http://lambda.uta.edu/ -- Creation: 02/15/08, last update: 03/23/08 +- Creation: 02/15/08, last update: 03/25/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. @@ -62,7 +62,8 @@ ',' { COMMA } ':=' { ASSIGN } 'where' { WHERE } - 'orderby' { ORDERBY } + 'order' { ORDER } + 'by' { BY } 'ascending' { ASCENDING } 'descending' { DESCENDING } 'element' { ELEMENT } @@ -158,9 +159,12 @@ 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]) } let_bindings : var ':=' expr { \x -> Ast "let" [$1,$3,x] } | let_bindings ',' @@ -169,8 +173,8 @@ opt_where : 'where' expr { \x -> Ast "predicate" [$2,x] } | {- empty -} { id } -opt_order : 'orderby' order_list { (\x -> Ast "sortTuple" (x:(fst $2)), - \x -> Ast "sort" (x:(snd $2))) } +opt_order : 'order' 'by' order_list { (\x -> Ast "sortTuple" (x:(fst $3)), + \x -> Ast "sort" (x:(snd $3))) } | {- empty -} { (id,id) } order_list : expr mode { ([$1],[$2]) } @@ -205,20 +209,20 @@ attributes : 'QName' '=' 'String' { [Ast "pair" [Astring $1,Astring $3]] } | 'QName' '=' '\'{' expr '}\'' { [Ast "pair" [Astring $1,$4]] } - | attributes 'QName' '=' 'String' { (Ast "pair" [Astring $2,Astring $4]):$1 } + | attributes 'QName' '=' 'String' { $1++[Ast "pair" [Astring $2,Astring $4]] } | attributes 'QName' '=' - '\'{' expr '}\'' { (Ast "pair" [Astring $2,$5]):$1 } + '\'{' expr '}\'' { $1++[Ast "pair" [Astring $2,$5]] } full_path : predicate_step { $1 "child" (Avar ".") } - | '@' predicate_step { $2 "attribute" (Avar ".") } + | '@' predicate_step { $2 "child_attribute" (Avar ".") } | predicate_step path { $2($1 "child" (Avar ".")) } - | '@' predicate_step path { $3($2 "attribute" (Avar ".")) } + | '@' predicate_step path { $3($2 "child_attribute" (Avar ".")) } path : step { $1 } | path step { $2 . $1 } step : '/' predicate_step { \e -> $2 "child" e } - | '/' '@' predicate_step { \e -> $3 "attribute" 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] } @@ -268,7 +272,7 @@ concatAll :: [Ast] -> Ast -concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs +concatAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs concatAll _ = call "empty" [] @@ -279,7 +283,7 @@ = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD | TEQ | TNEQ | TLT | LEQ | TGT | GEQ | AND | OR | NOT | UNION | INTERSECT - | EXCEPT | FOR | LET | IN | COMMA | ASSIGN | WHERE | ORDERBY | ASCENDING + | 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 @@ -300,6 +304,7 @@ 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 @@ -321,6 +326,7 @@ = 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 @@ -329,8 +335,10 @@ 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 @@ -360,6 +368,10 @@ 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 @@ -382,7 +394,8 @@ ("let",rest) -> LET : lexer rest n ("in",rest) -> IN : lexer rest n ("where",rest) -> WHERE : lexer rest n - ("orderby",rest) -> ORDERBY : 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 diff --git a/data/q1.xq b/data/q1.xq --- a/data/q1.xq +++ b/data/q1.xq @@ -2,7 +2,7 @@ { for $s in doc('data/cs.xml')//gradstudent - orderby $s/gpa descending, $s//lastname + order by $s/gpa descending, $s//lastname return f( $s/name, $s/gpa/text() ) } diff --git a/index.html b/index.html --- a/index.html +++ b/index.html @@ -37,7 +37,7 @@ 
 yum install ghc happy
-Then download HXQ and untar it. +Then download HXQ and untar it. You can either use cabal or make to build it. Then run xquery to test drive it.

Current Status

@@ -88,7 +88,7 @@ main = do a <- $(xq ("<result>{ " ++" for $x in doc('data/dblp.xml')//inproceedings at $i " ++" where $x/author = 'Leonidas Fegaras' " - ++" orderby $x/year descending " + ++" order by $x/year descending " ++" return <paper>{ $i, ') ', $x/booktitle/text(), " ++" ': ', $x/title/text() " ++" }</paper> "