HXQ 0.7.4 → 0.8

raw patch · 25 files changed

+3871/−3191 lines, 25 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• HXQ.cabal +7/−3
• HXQ.hs +11/−10
• Main.hs +5/−5
• Makefile +22/−16
• Test1.hs +1/−1
• Test2.hs +1/−1
• TestDB.hs +28/−0
• XML/HXQ/Compiler.hs +760/−0
• XML/HXQ/DB.hs +59/−0
• XML/HXQ/Interpreter.hs +352/−0
• XML/HXQ/Optimizer.hs +156/−0
• XML/HXQ/Parser.hs +2080/−0
• XML/HXQ/XQuery.hs +33/−0
• XML/HXQ/XQueryDB.hs +38/−0
• XML/HXQ/XTree.hs +101/−0
• XQuery.hs +0/−25
• XQueryCompiler.hs +0/−563
• XQueryInterpreter.hs +0/−222
• XQueryOptimizer.hs +0/−156
• XQueryParser.hs +0/−2080
• XQueryParser.y +1/−1
• XTree.hs +0/−101
• data/company.sql +189/−0
• index.html +24/−4
• profile.hs +3/−3

@@ -1,6 +1,6 @@ Cabal-Version:       >= 1.2 Name:                HXQ-Version:             0.7.4+Version:             0.8 Synopsis:            A Compiler from XQuery to Haskell Description:                  HXQ is a fast and space-efficient compiler from XQuery (the standard@@ -19,9 +19,12 @@ Extra-Source-Files:   Makefile   HXQ.hs+  XML/HXQ/DB.hs+  XML/HXQ/XQueryDB.hs   XQueryParser.y   Test1.hs   Test2.hs+  TestDB.hs   profile.hs   compile data-files:@@ -31,12 +34,13 @@   data/q2.xq   data/dblp.xq   data/dblp2.xq+  data/company.sql   hxml-0.2/00-LICENSE.txt   hxml-0.2/00-README.txt  Library-  Exposed-Modules:     XQuery-  Other-Modules:       XTree, XQueryCompiler, XQueryInterpreter, XQueryParser, XQueryOptimizer,+  Exposed-Modules:     XML.HXQ.XQuery+  Other-Modules:       XML.HXQ.XTree, XML.HXQ.Compiler, XML.HXQ.Interpreter, XML.HXQ.Parser, XML.HXQ.Optimizer,                        HXML, DTD, LLParsing, TreeBuild, XMLParse, ETree, Misc, Tree,                        XMLScanner, AssocList, PrintXML, XML   hs-source-dirs:      . hxml-0.2

@@ -14,14 +14,14 @@ import Packages import PackageConfig import System.IO-import XQuery+import XML.HXQ.XQuery import System.Environment import qualified Control.Exception-import XQueryCompiler(functions)-import XQueryInterpreter(evalInput)+import XML.HXQ.Compiler(functions)+import XML.HXQ.Interpreter(evalInput)  -version = "0.7.4"+version = "0.8" default_system_path = "/usr/local/lib/ghc-6.8.2" default_hxq_path = "./" @@ -56,7 +56,7 @@                    Just file -> do query <- readFile file                                    let qf = map (\c -> if c=='\"' then '\'' else c)                                                 (foldr1 (\a r -> a++" "++r) (lines query))-                                       pr = "{-# OPTIONS_GHC -fth #-}\nmodule Main where\nimport XQuery\n\nmain = do res <- $(xq \""+                                       pr = "{-# OPTIONS_GHC -fth #-}\nmodule Main where\nimport XML.HXQ.XQuery\n\nmain = do res <- $(xq \""                                             ++ qf ++ "\")\n          putXSeq res\n"                                        Just ofile = lookup "o" env                                    writeFile ofile pr@@ -64,14 +64,14 @@                            dflags0 <- getSessionDynFlags session                            (dflags1,b) <- parseDynamicFlags dflags0 ["-fglasgow-exts", "-O2", "-fth", "-fobject-code",                                                                      --"-package HXQ", "-package ghc"]-                                                                     "-i"++hxq_path++":"++hxq_path++"hxml-0.2"]+                                                                     "-i"++hxq_path++"XML/HXQ/:"++hxq_path++"hxml-0.2"]                            (dflags2, _) <- initPackages dflags1                            setSessionDynFlags session dflags2                            --load session LoadAllTargets                            let preludeModule = mkModule (stringToPackageId "base") (mkModuleName "Prelude")                            --xqueryModule = mkModule (stringToPackageId "HXQ") (mkModuleName "XQuery")                            setContext session [] [preludeModule]-                           t <- guessTarget (hxq_path++"XQuery.hs") Nothing+                           t <- guessTarget (hxq_path++"Main.hs") Nothing                            addTarget session t                            f <- getSessionDynFlags session                            sf <- defaultCleanupHandler f (load session LoadAllTargets)@@ -84,10 +84,11 @@                                              _ <- runStmt session query SingleStep                                              return ()                              _ -> case lookup "p" env of-                                    Just query -> do _ <- runStmt session ("do result <- $(XQuery.xq \""++query-                                                                           ++"\"); XQuery.putXSeq result") SingleStep+                                    Just query -> do _ <- runStmt session ("do result <- $(XML.HXQ.XQuery.xq \""++query+                                                                           ++"\"); XML.HXQ.XQuery.putXSeq result") SingleStep                                                      return ()                                     _ -> do putStrLn "To write an XQuery in multiple lines, wrap it in {}"-                                            evalInput (\s vs fs -> let query = "do result <- $(XQuery.xq \""++s++"\"); XQuery.putXSeq result"+                                            evalInput (\s vs fs -> let query = "do result <- $(XML.HXQ.XQuery.xq \""++s++"\");"+                                                                               ++"XML.HXQ.XQuery.putXSeq result"                                                                    in Control.Exception.catch (do runStmt session query SingleStep; return (vs,fs))                                                                               (\e -> do putStrLn (show e); return (vs,fs))) [] []

@@ -12,11 +12,11 @@  import System.Environment import qualified Control.Exception-import XQueryCompiler(functions)-import XQueryInterpreter(evalInput,xqueryE)-import XQuery+import XML.HXQ.Compiler(functions)+import XML.HXQ.Interpreter(evalInput,xqueryE)+import XML.HXQ.XQuery -version = "0.7.4"+version = "0.8"   parseEnv :: [String] -> [(String,String)]@@ -48,7 +48,7 @@                    Just file -> do query <- readFile file                                    let qf = map (\c -> if c=='\"' then '\'' else c)                                                 (foldr1 (\a r -> a++" "++r) (lines query))-                                       pr = "{-# OPTIONS_GHC -fth #-}\nmodule Main where\nimport XQuery\n\nmain = do res <- $(xq \""+                                       pr = "{-# OPTIONS_GHC -fth #-}\nmodule Main where\nimport XML.HXQ.XQuery\n\nmain = do res <- $(xq \""                                             ++ qf ++ "\")\n          putXSeq res\n"                                        Just ofile = lookup "o" env                                    writeFile ofile pr

@@ -1,41 +1,47 @@ hxml = hxml-0.2+hxq = XML/HXQ options = -O2 -fvia-C+parser = $(hxq)/Parser.hs  # xquery interpreter-xquery: XQueryParser.hs XQueryCompiler.hs XQueryInterpreter.hs XQuery.hs Main.hs+all:    $(parser) Main.hs 	ghc $(options) -i$(hxml) --make Main.hs -o xquery  # on-the-fly compiler: unstable; use xquery instead-hxqc:   XQueryParser.hs XQueryCompiler.hs XQueryInterpreter.hs XQuery.hs HXQ.hs-	ghc $(options) -i$(hxml) -package ghc --make HXQ.hs -o hxqc+hxqc:   $(parser) HXQ.hs+	ghc $(options) -i$(hxml) -optl-s -package ghc --make HXQ.hs -o hxqc  # generate the XQuery parser using happy-XQueryParser.hs: XQueryParser.y-	happy -g -a -c XQueryParser.y+$(parser): XQueryParser.y+	happy -g -a -c -o $(parser) XQueryParser.y -test1:	XQueryParser.hs-	ghc $(options) -i$(hxml) --make Test1.hs -o test1-	./test1+test1:  $(parser) Test1.hs+	ghc $(options) -i$(hxml) --make Test1.hs -o a.out+	./a.out -test2:	XQueryParser.hs-	ghc $(options) -i$(hxml) --make Test2.hs -o test2-	time ./test2 +RTS -H20m -M20m+test2:  $(parser) Test2.hs+	ghc $(options) -i$(hxml) --make Test2.hs -o a.out+	time ./a.out +RTS -H20m +testdb: $(parser) TestDB.hs+	ghc $(options) -i$(hxml) --make TestDB.hs -o a.out+	./a.out+ # get in the ghci interpreter and load HXQ-ghci:   XQueryParser.hs-	ghci -fth -i$(hxml) XQuery.hs+ghci:   $(parser)+	ghci -fth -i$(hxml) Main.hs  # heap profile of a simple XQuery against dblp.xml-profile: XQueryParser.hs+profile: $(parser) profile.hs 	ghc -O2 -i$(hxml) -prof -auto-all --make profile.hs -o a 	./a +RTS -hy -p -H20m 	hp2ps -color a.hp  # create the cabal distribution-cabal:	clean XQueryParser.hs+cabal:	clean $(parser) 	runhaskell Setup.lhs configure --ghc --user --prefix=$(HOME) 	runhaskell Setup.lhs build 	runhaskell Setup.lhs sdist  clean:-	/bin/rm -f *~ data/*~ *.o *.hi $(hxml)/*.o $(hxml)/*.hi XQueryParser.hs *.stat *.prof *.ps *.aux *.hp hxq hxqc test1 test2 Temp.hs a.out a+	/bin/rm -f *~ data/*~ $(hxq)/*~ *.o *.hi $(hxq)/*.o $(hxq)/*.hi $(hxml)/*.o $(hxml)/*.hi $(parser) *.stat *.prof *.ps *.aux *.hp xquery hxqc Temp.hs a.out a

@@ -10,7 +10,7 @@  module Main where -import XQuery+import XML.HXQ.XQuery   f(d,s) = $(xe "<student dept='{$d/text()}'>{$s//firstname/text(),' ',$s//lastname/text()}</student>")

@@ -11,7 +11,7 @@  module Main where -import XQuery+import XML.HXQ.XQuery   f(x,y) = $(xe "<a>{$x,', ',$y}</a>")

@@ -0,0 +1,28 @@+{--------------------------------------------------------------+-+- A main program to test XQuery with Sqlite database connectivity+- To create the database load the file data/company.sql in sqlite3+-+- Programmer: Leonidas Fegaras (fegaras@cse.uta.edu)+- Date: 05/12/2008+-+---------------------------------------------------------------}++{-# OPTIONS_GHC -fth #-}++module Main where++import XML.HXQ.XQueryDB+import Database.HDBC.Sqlite3+++main = do db <- connectSqlite3 "myDB"+          e <- $(xqdb ("  let $ln := 'English'                              "+                     ++"  for $r in sql('  select e.fname, d.dname          "+                     ++"                   from employee e, department d    "+                     ++"                   where e.dno = d.dnumber          "+                     ++"                     and e.lname = ?           ',   "+                     ++"                $ln)                                "+                     ++"  return <result>{$r/fname,$r/dname}</result>       ")) db+          putXSeq e+          disconnect db

@@ -0,0 +1,760 @@+{-------------------------------------------------------------------------------------+-+- A Compiler from XQuery to Haskell+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 02/15/08, last update: 05/12/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++{-# OPTIONS_GHC -fth -fbang-patterns #-}++module XML.HXQ.Compiler where++import Data.List+import Control.Monad+import Char(isDigit)+import List(sortBy)+import Language.Haskell.TH+import XMLParse(parseDocument)+import HXML(AttList)+import XML.HXQ.Parser+import XML.HXQ.XTree+import XML.HXQ.Optimizer+++{--------------- XPath Steps ---------------------------------------------------------}+++-- XPath step /tag or /*+child_step :: Tag -> XTree -> XSeq+child_step m x+    = case x of+        (XElem _ _ _ bs)+            -> foldr (\b s -> case b of+                                (XElem k _ _ _) | (k==m || m=="*") -> b:s+                                _ -> s) [] bs+        _ -> []+++-- XPath step //tag or //*+descendant_step :: Tag -> XTree -> XSeq+descendant_step m (x@(XElem t _ _ cs))+    | m==t || m=="*"+    = x:(concatMap (descendant_step m) cs)+descendant_step m (XElem t _ _ cs) = concatMap (descendant_step m) cs+descendant_step m _ = []+++-- It's like //* but has tagged children, which are derived statically+-- After examing 100 children it gives up: this avoids space leaks+descendant_any_with_tagged_children :: [Tag] -> XTree -> XSeq+descendant_any_with_tagged_children tags (x@(XElem t _ _ cs))+    | all (\tag -> foldr (\b s -> case b of+                                    (XElem k _ _ _) -> s || k == tag+                                    _ -> s) False cs100) tags+    = x:(concatMap (descendant_any_with_tagged_children tags) cs)+    where cs100 = take 100 cs+descendant_any_with_tagged_children tags (XElem t _ _ cs)+    = concatMap (descendant_any_with_tagged_children tags) cs+descendant_any_with_tagged_children tags _ = []+++-- XPath step /@attr or /@*+attribute_step :: Tag -> XTree -> XSeq+attribute_step m x+    = case x of+        (XElem _ al _ _) -> foldr (\(k,v) s -> if k==m || m=="*"+                                               then (XText v):s+                                               else s) [] al+        _ -> []+++-- XPath step //@attr or //@*+attribute_descendant_step :: Tag -> XTree -> XSeq+attribute_descendant_step m (x@(XElem _ al _ cs))+    = foldr (\(k,v) s -> if k==m || m=="*"+                         then (XText v):s+                         else s)+            (concatMap (attribute_descendant_step m) cs) al+attribute_descendant_step m _ = []+++{------------ Functions --------------------------------------------------------------}+++-- find the value of a variable in an association list+findV var env+  = case filter (\(n,_) -> n==var) env of+      (_,b):_ -> b+      _ -> error ("Undefined variable: "++var)++-- is the variable defined in the association list?+memV var env+  = case filter (\(n,_) -> n==var) env of+      (_,b):_ -> True+      _ -> False+++-- like foldr but with an index+foldir :: (a -> Int -> b -> b) -> b -> [a] -> Int -> b+foldir c n [] i = n+foldir c n (x:xs) i = c x i (foldir c n xs (i+1))++trueXT = XBool True++readNum :: String -> Maybe XTree+readNum cs = case span isDigit cs of+               (n,[]) -> Just (XInt (read n))+               (n,'.':rest) -> case span isDigit rest of+                                 (k,[]) -> Just (XFloat (read (n++('.':k))))+                                 _ -> Nothing+               _ -> Nothing++text :: XSeq -> XSeq+text xs = foldr (\x r -> case x of+                           XElem _ _ _ [z@(XText _)] -> z:r+                           XElem _ _ _ [z@(XInt _)] -> z:r+                           XElem _ _ _ [z@(XFloat _)] -> z:r+                           XElem _ _ _ [z@(XBool _)] -> z:r+                           XText _ -> x:r+                           XInt _ -> x:r+                           XFloat _ -> x:r+                           XBool _ -> x:r+                           _ -> r) [] xs++toString :: XSeq -> [String]+toString xs = map (\x -> case x of +                           XText t -> t+                           XInt n -> show n+                           XFloat n -> show n+                           XBool n -> show n)+                  (text xs)++toNum :: XSeq -> XSeq+toNum xs = foldr (\x r -> case x of+                            XInt n -> x:r+                            XFloat n -> x:r+                            XText s -> case readNum s of+                                         Just t -> t:r+                                         _ -> r+                            _ -> r) [] (text xs)++toFloat :: XTree -> Float+toFloat (XText s) = case readNum s of+                      Just (XInt n) -> fromIntegral n+                      Just (XFloat n) -> n+                      _ -> error("Cannot convert to a float: "++s)+toFloat (XInt n) = fromIntegral n+toFloat (XFloat n) = n+toFloat x = error("Cannot convert to a float: "++(show x))++mean :: (Fractional t) => [t] -> t+mean = uncurry (/) . foldl' (\(!s, !n) x -> (s+x, n+1)) (0,0.0)++contains :: String -> String -> Bool+contains xs ys | ((take (length ys) xs) == ys) = True+contains (_:xs) ys = contains xs ys+contains [] ys = False++distinct :: Eq a => [a] -> [a]+distinct = foldl (\r a -> if elem a r then r else r++[a]) []++arithmetic :: (Float -> Float -> Float) -> XTree -> XTree -> XTree+arithmetic op (XInt n) (XInt m) = XInt (round (op (fromIntegral n) (fromIntegral m)))+arithmetic op (XFloat n) (XFloat m) = XFloat (op n m)+arithmetic op (XFloat n) (XInt m) = XFloat (op n (fromIntegral m))+arithmetic op (XInt n) (XFloat m) = XFloat (op (fromIntegral n) m)++compareXTrees :: XTree -> XTree -> Ordering+compareXTrees (XElem _ _ _ _) _ = EQ+compareXTrees _ (XElem _ _ _ _) = EQ+compareXTrees (XInt n) (XInt m) = compare n m+compareXTrees (XFloat n) (XInt m) = compare n (fromIntegral m)+compareXTrees (XInt n) (XFloat m) = compare (fromIntegral n) m+compareXTrees (XFloat n) (XFloat m) = compare n m+compareXTrees (XText n) (XText m) = compare n m+compareXTrees x y = compare (toFloat x) (toFloat y)++strictCompareOne [XInt n] [XInt m] = compare n m+strictCompareOne [XFloat n] [XFloat m] = compare n m+strictCompareOne [XFloat n] [XInt m] = compare n (fromIntegral m)+strictCompareOne [XInt n] [XFloat m] = compare (fromIntegral n) m+strictCompareOne [XText n] [XText m] = compare n m+strictCompareOne x y = error ("Illegal operands in strict comparison: "++(show x)++" "++(show y))++strictCompare :: XSeq -> XSeq -> Ordering+strictCompare [XElem _ _ _ x] [XElem _ _ _ y] = strictCompareOne x y+strictCompare x [XElem _ _ _ y] = strictCompareOne x y+strictCompare [XElem _ _ _ x] y = strictCompareOne x y+strictCompare x y = strictCompareOne x y++compareXSeqs :: Bool -> XSeq -> XSeq -> Ordering+compareXSeqs ord xs ys+    = let comps = [ compareXTrees x y | x <- xs, y <- ys ]+      in if ord+            then if all (\x -> x == LT) comps+                    then LT+                 else if all (\x -> x == GT) comps+                    then GT+                 else EQ+         else if all (\x -> x == LT) comps+                 then GT+              else if all (\x -> x == GT) comps+                 then LT+              else EQ++conditionTest :: XSeq -> Bool+conditionTest [] = False+conditionTest [XText ""] = False+conditionTest [XInt 0] = False+conditionTest [XBool False] = False+conditionTest _ = True+++-- XPath steps+paths :: [(Tag,Q Exp)]+paths = [ ( "child_step", [| child_step |] ),+          ( "descendant_step", [| descendant_step |] ),+          ( "attribute_step", [| attribute_step |] ),+          ( "attribute_descendant_step", [| attribute_descendant_step |] )+        ]+++type Function = [Q Exp] -> Q Exp++-- System functions: they can also be defined as Haskell functions of type (XSeq,...,XSeq) -> XSeq+-- but here we make sure they are unfolded and fused with the rest of the query+functions :: [(Tag,Int,Function)]+functions = [ ( "=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] |] ),+              ( "!=", 2, \[xs,ys] -> [| if null [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] then [trueXT] else [] |] ),+              ( ">", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == GT ] |] ),+              ( "<", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == LT ] |] ),+              ( ">=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [GT,EQ] ] |] ),+              ( "<=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [LT,EQ] ] |] ),+              ( "eq", 2, \[xs,ys] -> [| if strictCompare $xs $ys == EQ then [trueXT] else [] |] ),+              ( "neq", 2, \[xs,ys] -> [| if strictCompare $xs $ys /= EQ then [trueXT] else [] |] ),+              ( "lt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == LT then [trueXT] else [] |] ),+              ( "gt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == GT then [trueXT] else [] |] ),+              ( "le", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [LT,EQ] then [trueXT] else [] |] ),+              ( "ge", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [GT,EQ] then [trueXT] else [] |] ),+              ( "<<", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox < oy ] |] ),+              ( ">>", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox > oy ] |] ),+              ( "is", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox == oy ] |] ),+              ( "+", 2, \[xs,ys] -> [| [ arithmetic (+) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+              ( "-", 2, \[xs,ys] -> [| [ arithmetic (-) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+              ( "*", 2, \[xs,ys] -> [| [ arithmetic (*) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+              ( "div", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ),+              ( "idiv", 2, \[xs,ys] -> [| [ XInt (div x y) | (XInt x) <- toNum $xs, (XInt y) <- toNum $ys ] |] ),+              ( "mod", 2, \[xs,ys] -> [| [ XInt (mod x y) | (XInt x) <- toNum $xs, (XInt y) <- toNum $ys ] |] ),+              ( "uplus", 1, \[xs] -> [| [ x | x <- toNum $xs ] |] ),+              ( "uminus", 1, \[xs] -> [| [ case x of XInt n -> XInt (-n); XFloat n -> XFloat (-n) | x <- toNum $xs ] |] ),+              ( "and", 2, \[xs,ys] -> [| if (conditionTest $xs) && (conditionTest $ys) then [trueXT] else [] |] ),+              ( "or", 2, \[xs,ys] -> [| if (conditionTest $xs) || (conditionTest $ys) then [trueXT] else [] |] ),+              ( "not", 1, \[xs] -> [| if (conditionTest $xs) then [] else [trueXT] |] ),+              ( "some", 1, \[xs] -> [| if (conditionTest $xs) then [trueXT] else [] |] ),+              ( "count", 1, \[xs] -> [| [ XInt (length $xs) ] |] ),+              ( "sum", 1, \[xs] -> [| [ XFloat (sum [ toFloat x | x <- toNum $xs ]) ] |] ),+              ( "avg", 1, \[xs] -> [| [ XFloat (mean [ toFloat x | x <- toNum $xs ]) ] |] ),+              ( "min", 1, \[xs] -> [| [ XFloat (minimum [ toFloat x | x <- toNum $xs ]) ] |] ),+              ( "max", 1, \[xs] -> [| [ XFloat (maximum [ toFloat x | x <- toNum $xs ]) ] |] ),+              ( "to", 2, \[xs,ys] -> [| [ XInt i | XInt n <- toNum $xs, XInt m <- toNum $ys, i <- [n..m] ] |] ),+              ( "text", 1, \[xs] -> [| text $xs |] ),+              ( "string", 1, \[xs] -> [| text $xs |] ),+              ( "data", 1, \[xs] -> [| text $xs |] ),+              ( "node", 1, \[xs] -> [| $xs |] ),+              ( "empty", 0, \[] -> [| [] |] ),+              ( "true", 0, \[] -> [| [trueXT] |] ),+              ( "false", 0, \[] -> [| [] |] ),+              ( "if", 3, \[cs,ts,es] -> [| if conditionTest $cs then $ts else $es |] ),+              ( "element", 2, \[tags,xs] -> [| [ x | tag <- toString $tags, x@(XElem t _ _ _) <- $xs, (t==tag || tag=="*") ] |] ),+              ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute_step tag x ] |] ),+              ( "name", 1, \[xs] -> [| [ XText tag | XElem tag _ _ _ <- $xs ] |] ),+              ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ),+              ( "concatenate", 2, \[xs,ys] -> [| $xs ++ $ys |] ),+              ( "concat", 2, \[xs,ys] -> [| [ XText (showXS ($xs ++ $ys)) ] |] ),+              ( "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  |] ),+              ( "reverse", 1, \[xs] -> [| reverse $xs |] )+            ]+++-- functions to be used by the interpreter+-- when evaluated, it gives [(String,Int,[XSeq]->XSeq)]+iFunctions :: Q Exp+iFunctions = foldr (\(fname,len,f) r -> let vars = map (\i -> mkName ("v_"++(show i))) [1..len]+                                            entry = tupE [litE (StringL fname),litE (IntegerL (toInteger len)),+                                                          lamE [listP (map varP vars)] (f (map varE vars))]+                                        in [| $entry : $r |]) [| [] |] functions+++-- XPath steps to be used by the interpreter+-- when evaluated, it gives [(String,Tag->XTree->XSeq)]+pFunctions = foldr (\(pname,p) r -> let pn = litE (StringL pname) in [| ($pn,$p) : $r |]) [| [] |] paths+++-- make a function call+callF :: Tag -> Function+callF fname args = case filter (\(n,_,_) -> n == fname || ("fn:"++n)==fname) functions of+                     (_,len,f):_ -> if (length args) == len+                                       then f args+                                    else error ("wrong number of arguments in function call: " ++ fname)+                     _ ->     -- otherwise, it must be a Haskell function of type (XSeq,...,XSeq) -> XSeq+                          let itp = case args of+                                      [] -> [t| () |]+                                      [_] -> [t| XSeq |]+                                      _ -> foldr (\_ r -> appT r [t| XSeq |]) (appT (tupleT (length args)) [t| XSeq |])+                                                 (tail args)+                              fn = sigE (varE (mkName fname))+                                        (appT (appT arrowT itp) [t| XSeq |])+                          in appE fn (tupE args)+++{------------ Compiler ---------------------------------------------------------------}+++undef1 = [| error "Undefined XQuery context (.)" |]+undef2 = [| error "Undefined position()" |]+undef3 = [| error "Undefined last()" |]+++-- does the expression contain a last()?+containsLast :: Ast -> Bool+containsLast (Ast "step" [Ast "call" [Avar "last"]]) = True+containsLast (Ast f _) | elem f ["let","for","predicate"] = False+containsLast (Ast "step" _) = False+containsLast (Ast _ args) = or (map containsLast args)+containsLast _ = False+++-- calculate the maximum position value used in a predicate, if there is one+maxPosition :: Ast -> Ast -> Int+maxPosition position e+    = case e of+        Ast "call" [Avar f,Ast "step" [p],Aint n]+            | f `elem` ["=","<","<=","eq","lt","le"] && p == position+            -> n+        Ast "call" [Avar f,Aint n,Ast "step" [p]]+            | f `elem` ["=",">",">=","eq","gt","ge"] && p == position+            -> n+        Ast "let" [Avar x,source,body]+            -> if position == Avar x+               then 0 else minp (maxPosition position source) (maxPosition position body)+        Ast "for" [Avar x,Avar i,source,body]+            -> if position == Avar x || position == Avar i+               then 0 else minp (maxPosition position source) (maxPosition position body)+        Ast "predicate" [pred,body]+            -> minp (maxPosition position pred) (maxPosition position body)+        Ast "call" [Avar "and",x,y]+            -> minp (maxPosition position x) (maxPosition position y)+        Ast "call" [Avar "or",x,y]+            -> max (maxPosition position x) (maxPosition position y)+        _ -> 0+    where minp x y = if x == 0 then y else if y == 0 then x else min x y+++pathPosition = Ast "call" [Avar "position"]+++-- extract the QName+qName :: XSeq -> Tag+qName [XText s] = s+qName e = error ("Invalid QName: "++(show e))+++-- Each XPath predicate must calculate position() and last() from its input XSeq+-- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)+compilePredicates :: [Ast] -> Q Exp -> Bool -> Q Exp+compilePredicates [] xs _ = xs+compilePredicates ((Aint n):preds) xs _   -- shortcut that improves laziness+    = compilePredicates preds+            [| [ $xs !! $(litE (IntegerL (toInteger (n-1)))) ] |] True+compilePredicates (pred:preds) xs True    -- top-k like+    | maxPosition pathPosition pred > 0+    = compilePredicates (pred:preds)+           [| take $(litE (IntegerL (toInteger (maxPosition pathPosition pred)))) $xs |] False+compilePredicates (pred:preds) xs _+    | containsLast pred         -- blocking: use only when last() is used in the predicate+    = compilePredicates preds+            [| let bl = $xs+                   len = length bl+               in foldir (\x i r -> if case $(compile pred [| x |] [| [XInt i] |] [| [XInt len] |] "") of+                                         [XInt k] -> k == i               -- indexing+                                         b -> conditionTest b+                                    then x:r else r) [] bl 1 |] True+compilePredicates (pred:preds) xs _+    = compilePredicates preds+            [| foldir (\x i r -> if case $(compile pred [| x |] [| [XInt i] |] undef3 "") of+                                      [XInt k] -> k == i               -- indexing+                                      b -> conditionTest b+                                 then x:r else r) [] $xs 1 |] True+++-- Compile the AST e into Haskell code+-- context: context node (XPath .)+-- position: the element position in the parent sequence (XPath position())+-- last: the length of the parent sequence (XPath last())+-- effective_axis: the XPath axis in /axis::tag(exp)+--        (eg, the effective axis of //(A | B) is "descendant_step"+compile :: Ast -> Q Exp -> Q Exp -> Q Exp -> String -> Q Exp+compile e context position last effective_axis+  = case e of+      Avar "." -> [| [ $context :: XTree ] |]+      Avar v -> let x = varE (mkName v)+                in [| $x :: XSeq |]+      Aint n -> let x = litE (IntegerL (toInteger n))+                in [| [ XInt $x ] |]+      Afloat n -> let x = litE (RationalL (toRational n))+                  in [| [ XFloat $x ] |]+      Astring s -> let x = litE (StringL s)+                   in [| [ XText $x ] |]+      Ast "context" [v,Astring dp,body]+          -> [| foldr (\x r -> $(compile body [| x |] position last dp)++r)+                      [] $(compile v context position last effective_axis) |]+      Ast "call" [Avar "position"]+          -> position+      Ast "call" [Avar "last"]+          -> last+      Ast "step" [Ast "child_step" [tag, Avar "."]]+          | effective_axis /= ""+          -> compile (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last ""+      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)+          -> let bc = compile body context position last effective_axis+                 ts = listE (map (\(Avar tag) -> litE (stringL tag)) tags)+             in [| foldr (\x r -> $(compilePredicates predicates [| descendant_any_with_tagged_children $ts x |] True)++r)+                         [] $bc |]+      Ast "step" ((Ast path_step [Astring tag,body]):predicates)+          |  memV path_step paths+          -> let bc = compile body context position last effective_axis+                 tc = litE (stringL tag)+             in [| foldr (\x r -> $(compilePredicates predicates [| $(findV path_step paths) $tc x |] True)++r)+                         [] $bc |]+      Ast "step" [exp]+          -> compile exp context position last effective_axis+      Ast "step" (exp:predicates)+          -> compilePredicates predicates (compile exp context position last effective_axis) True+      Ast "predicate" [condition,body]+          -> compilePredicates [condition] (compile body context position last effective_axis) True+      Ast "call" ((Avar f):args)+          -> callF f (map (\x -> compile x context position last effective_axis) args)+      Ast "construction" [Astring tag,Ast "attributes" [],body]+          -> let ct = litE (StringL tag)+                 bc = compile body context position last effective_axis+             in [| [ XElem $ct [] 0 $bc ] |]+      Ast "construction" [tag,Ast "attributes" al,body]+          -> let alc = foldr (\(Ast "pair" [a,v]) r+                                  -> let ac = compile a context position last effective_axis+                                         vc = compile v context position last effective_axis+                                     in [| (qName $ac,showXS (text $vc)) : $r |]) [| [] |] al+                 ct = compile tag context position last effective_axis+                 bc = compile body context position last effective_axis+             in [| [ XElem (qName $ct) $alc 0 $bc ] |]+      Ast "let" [Avar var,source,body]+          -> do s <- compile source context position last effective_axis+                b <- compile body context position last effective_axis+                return (AppE (LamE [VarP (mkName var)] b) s)+      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index+          -> let b = compile body [| head $(varE (mkName var)) |] undef2 undef3 ""+                 f = lamE [varP (mkName var)] [| \r -> $b ++ r |]+                 s = compile source context position last effective_axis+             in [| foldr (\x -> $f [x]) [] $s |]+      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index+          -> let b = compile body [| head $(varE (mkName var)) |]+                             [| $(varE (mkName ivar)) |] undef3 ""+                 f = lamE [varP (mkName var)] (lamE [varP (mkName ivar)] [| \r -> $b ++ r |])+                 p = maxPosition (Avar ivar) body+                 ns = if p > 0              -- there is a top-k like restriction+                      then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]+                      else source+                 s = compile ns context position last effective_axis+             in [| foldir (\x i -> $f [x] [XInt i]) [] $s 1 |]+      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting+          -> let res = foldl (\r a -> let ac = compile a context position last effective_axis+                                      in [| $r++[text $ac] |] )+                             [| [ $(compile exp context position last effective_axis) ] |] orderBys+             in [| [ $res ] |]+      Ast "sort" (exp:ordList)                   -- blocking+          -> let ce = compile exp context position last effective_axis+                 ordering = foldr (\(Avar ord) r+                                       -> let asc = if ord == "ascending"+                                                    then [| True |]+                                                    else [| False |]+                                          in [| \(x:xs) (y:ys) -> case compareXSeqs $asc x y of+                                                                    EQ -> $r xs ys+                                                                    o -> o |])+                                  [| \xs ys -> EQ |] ordList+             in [| concatMap head (sortBy (\(_:xs) (_:ys) -> $ordering xs ys) ($ce::[[XSeq]])) |]+      _ -> error ("Illegal XQuery: "++(show e))+++-- The monadic compilePredicates that propagates IO state+compilePredicatesM :: [Ast] -> Q Exp -> Bool -> Q Exp+compilePredicatesM [] xs _+    = [| return $xs |]+compilePredicatesM ((Aint n):preds) xs _   -- shortcut that improves laziness+    = compilePredicatesM preds+            [| [ $xs !! $(litE (IntegerL (toInteger (n-1)))) ] |] True+compilePredicatesM (pred:preds) xs True    -- top-k like+    | maxPosition pathPosition pred > 0+    = compilePredicatesM (pred:preds)+           [| take $(litE (IntegerL (toInteger (maxPosition pathPosition pred)))) $xs |] False+compilePredicatesM (pred:preds) xs _+    | containsLast pred         -- blocking: use only when last() is used in the predicate+    = [| do let bl = $xs+                last = length bl+            vs <- foldir (\x i r -> do vs <- $(compileM pred [| x |] [| [XInt i] |] [| [XInt last] |] "")+                                       s <- r+                                       return (if case vs of+                                                    [XInt k] -> k == i               -- indexing+                                                    b -> conditionTest b+                                               then x:s else s))+                         (return []) $xs 1+            $(compilePredicatesM preds [| vs |] True) |]+compilePredicatesM (pred:preds) xs _+    = [| do vs <- foldir (\x i r -> do vs <- $(compileM pred [| x |] [| [XInt i] |] undef3 "")+                                       s <- r+                                       return (if case vs of+                                                    [XInt k] -> k == i               -- indexing+                                                    b -> conditionTest b+                                               then x:s else s))+                         (return []) $xs 1+            $(compilePredicatesM preds [| vs |] True) |]+++-- The monadic XQuery compiler; it is like compile but has plumbing to propagate IO state+compileM :: Ast -> Q Exp -> Q Exp -> Q Exp -> String -> Q Exp+compileM e context position last effective_axis+  = case e of+      Avar "." -> [| return [ $context :: XTree ] |]+      Avar v -> let x = varE (mkName v)+                in [| return ($x :: XSeq) |]+      Aint n -> let x = litE (IntegerL (toInteger n))+                in [| return [ XInt $x ] |]+      Afloat n -> let x = litE (RationalL (toRational n))+                  in [| return [ XFloat $x ] |]+      Astring s -> let x = litE (StringL s)+                   in [| return [ XText $x ] |]+      -- for non-IO XQuery, use the regular compile+      Ast "nonIO" [u] -> [| return $(compile u context position last effective_axis) |]+      Ast "context" [v,Astring dp,body]+          -> [| do vs <- $(compileM v context position last effective_axis)+                   foldr (\x r -> (liftM2 (++)) $(compileM body [| x |] position last dp) r)+                         (return []) vs |]+      Ast "call" [Avar "position"]+          -> [| return $position |]+      Ast "call" [Avar "last"]+          -> [| return $last |]+      Ast "step" [Ast "child_step" [tag, Avar "."]]+          | effective_axis /= ""+          -> compileM (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last ""+      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)+          -> let bc = compileM body context position last effective_axis+                 ts = listE (map (\(Avar tag) -> litE (stringL tag)) tags)+             in [| do vs <- $bc+                      foldr (\x r -> (liftM2 (++)) $(compilePredicatesM predicates+                                                         [| descendant_any_with_tagged_children $ts x |] True) r)+                            (return []) vs |]+      Ast "step" ((Ast path_step [Astring tag,body]):predicates)+          |  memV path_step paths+          -> let bc = compileM body context position last effective_axis+                 tc = litE (stringL tag)+             in [| do vs <- $bc+                      foldr (\x r -> (liftM2 (++)) $(compilePredicatesM predicates+                                                           [| $(findV path_step paths) $tc x |] True) r)+                            (return []) vs |]+      Ast "step" [exp]+          -> compileM exp context position last effective_axis+      Ast "step" (exp:predicates)+          -> [| do vs <- $(compileM exp context position last effective_axis)+                   $(compilePredicatesM predicates [| vs |] True) |]+      Ast "predicate" [condition,body]+          -> [| do vs <- $(compileM body context position last effective_axis)+                   $(compilePredicatesM [condition] [| vs |] True) |]+      Ast "executeSQL" [Avar stmt,args]+          -> [| do as <- $(compileM args context position last effective_axis)+                   $(varE (mkName "executeSQL")) $(varE (mkName stmt)) as |]+      Ast "call" ((Avar f):args)+          -> let binds = zipWith (\i x -> (mkName ("x"++(show i)),x)) [1..(length args)] args+             in foldr (\(n,x) r -> [| $(compileM x context position last effective_axis) >>= $(lamE [varP n] r) |])+                      [| return $(callF f (map (\(n,_) -> varE n) binds)) |] binds+      Ast "construction" [Astring tag,Ast "attributes" [],body]+          -> let ct = litE (StringL tag)+                 bc = compileM body context position last effective_axis+             in [| do b <- $bc+                      return [ XElem $ct [] 0 b ] |]+      Ast "construction" [tag,Ast "attributes" al,body]+          -> let alc = foldr (\(Ast "pair" [a,v]) r+                                  -> [| do ac <- $(compileM a context position last effective_axis)+                                           vc <- $(compileM v context position last effective_axis)+                                           s <- $r+                                           return ((qName ac,showXS (text vc)):s) |]) [| return [] |] al+                 ct = compileM tag context position last effective_axis+                 bc = compileM body context position last effective_axis+             in [| do a <- $alc+                      c <- $ct+                      b <- $bc+                      return [ XElem (qName c) a 0 b ] |]+      Ast "let" [Avar var,source,body]+          -> [|  $(compileM source context position last effective_axis)+                 >>= $(lamE [varP (mkName var)] (compileM body context position last effective_axis)) |]+      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index+          -> let b = compileM body [| head $(varE (mkName var)) |] undef2 undef3 ""+                 f = lamE [varP (mkName var)] [| (liftM2 (++)) $b |]+                 s = compileM source context position last effective_axis+             in [| do vs <- $s+                      foldr (\x -> $f [x]) (return []) vs |]+      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index+          -> let b = compileM body [| head $(varE (mkName var)) |]+                             [| $(varE (mkName ivar)) |] undef3 ""+                 f = lamE [varP (mkName var)] (lamE [varP (mkName ivar)] [| (liftM2 (++)) $b |])+                 p = maxPosition (Avar ivar) body+                 ns = if p > 0              -- there is a top-k like restriction+                      then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]+                      else source+                 s = compileM ns context position last effective_axis+             in [| do vs <- $s+                      foldir (\x i -> $f [x] [XInt i]) (return []) vs 1 |]+      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting+          -> let vs = compileM exp context position last effective_axis+                 res = foldl (\r a -> [| do ac <- $(compileM a context position last effective_axis)+                                            s <- $r+                                            return (s++[text ac]) |] )+                             [| do v <- $vs; return [ v ] |] orderBys+             in [| return $res |]+      Ast "sort" (exp:ordList)                   -- blocking+          -> let ce = compileM exp context position last effective_axis+                 ordering = foldr (\(Avar ord) r+                                       -> let asc = if ord == "ascending"+                                                    then [| True |]+                                                    else [| False |]+                                          in [| \(x:xs) (y:ys) -> case compareXSeqs $asc x y of+                                                                    EQ -> $r xs ys+                                                                    o -> o |])+                                  [| \xs ys -> EQ |] ordList+             in [| do c <- $ce+                      return (concatMap head (sortBy (\(_:xs) (_:ys) -> $ordering xs ys) (c::[[XSeq]]))) |]+      _ -> error ("Illegal XQuery: "++(show e))+++-- functions that need IO interaction (document reader, DB access, etc)+ioSources :: [ String ]+ioSources = ["executeSQL","doc","fn:doc","sql","fn:sql"]+++-- collect all input documents and assign them a unique number+pullIOSources :: Ast -> Int -> (Ast, Int, [(String, Ast)])+pullIOSources query count+    = case query of+             Ast "call" [Avar nm,file]+                 | elem nm ["doc","fn:doc"]+                 -> (Avar ("_doc"++(show count)), count+1, [("_doc"++(show count),file)])+             Ast "call" [Avar nm,sql,args]+                 | elem nm ["sql","fn:sql"]+                 -> (Ast "executeSQL" [Avar ("_sql"++(show count)),args], count+1,+                     [("_sql"++(show count),Ast "prepareSQL" [sql])])+             Ast n args+                 -> let (s,c,ns) = foldr (\a r c -> let (e,c1,n1) = pullIOSources a c+                                                        (s,c2,n2) = r c1+                                                    in (e:s,c2,union n1 n2))+                                         (\c -> ([],c,[])) args count+                    in (Ast n s,c,ns)+             _ -> (query,count,[])+    where union xs ((n,s):ys) = (n,foldr(\(m,d) r -> if s==d then Avar m else r) s xs):(union xs ys)+          union xs [] = xs+++-- true if there is no need to lift to the IO monad+noIO :: Ast -> Bool+noIO (Ast nm _) | elem nm ioSources = False+noIO (Ast n args) = all noIO args+noIO _ = True+++liftIOSources :: Ast  -> (Ast, [(String, Ast)])+liftIOSources query+    = let (ast,_,ns) = pullIOSources query 0+          f x = case x of+                  Ast _ _ | noIO x -> Ast "nonIO" [x]+                  _ -> case x of+                         Ast "call" ((Avar nm):args)+                             -> Ast "call" ((Avar nm):(map f args))+                         Ast n args -> Ast n (map f args)+                         _ -> x+      in (f ast,ns)+++-- optimize and compile an AST (unlifted)+compileAst :: Ast -> Q Exp+compileAst ast = compile (optimize ast) undef1 undef2 undef3 ""+++-- optimize and compile an AST (IO lifted)+compileAstM :: Ast -> Q Exp+compileAstM ast = compileM (optimize ast) undef1 undef2 undef3 ""+++-- compile an XQuery AST that reads XML documents+compileQuery :: [Ast] -> Q Exp+compileQuery ((Ast "function" ((Avar f):b:args)):xs)+    = let lvars = case args of+                    [Astring a] -> [varP (mkName a)]+                    _ -> [tupP (map (\(Avar a) -> varP (mkName a)) args)]+      in letE [valD (varP (mkName f)) (normalB (lamE lvars (compileAst b))) []]+              (compileQuery xs)+compileQuery ((Ast "variable" [Avar v,u]):xs)+    = letE [valD (varP (mkName v)) (normalB (compileAst u)) []]+           (compileQuery xs)+compileQuery [query]+    = let (ast,ns) = liftIOSources query+          code = compileAstM ast+      in foldl (\r (n,e) -> let d = lamE [varP (mkName n)] r+                            in case e of+                                 Avar m -> [| $d $(varE (mkName m)) |]+                                 Ast "prepareSQL" [Astring sql]+                                     -> [| ($(varE (mkName "prepareSQL"))+                                                    $(varE (mkName "_db"))+                                                    $(litE (StringL sql))) >>= $d |]+                                 _ -> [| do let [XText f] = $(compileAst e)+                                            doc <- readFile f+                                            $d [materialize (parseDocument doc)] |])+               [| $code |] ns+++-- | Debugging: display the AST and the Haskell code of an input XQuery+cq :: String -> IO ()+cq query = do putStrLn "Abstract Syntax Tree:"+              let ast = parse (scan query)+              putStrLn (show ast)+              let opt = optimize (last ast)+              putStrLn "Optimized AST:"+              putStrLn (show opt)+              putStrLn "Haskell Code:"+              let code = compileQuery ast+              runQ code >>= putStrLn.pprint+++-- | Run an XQuery expression that does not read XML documents.+-- When evaluated, it returns XSeq.+xe :: String -> Q Exp+xe query = compileAst (last (parse (scan query)))+++-- | Run an XQuery that reads XML documents.+-- When evaluated, it returns IO XSeq.+xq :: String -> Q Exp+xq query = compileQuery (parse (scan query))+++-- | Run an XQuery that reads XML documents and queries databases.+-- When evaluated, it returns (IConnection conn) => conn -> IO XSeq.+xqdb :: String -> Q Exp+xqdb query = (lamE [varP (mkName "_db")] (xq query))

@@ -0,0 +1,59 @@+{-------------------------------------------------------------------------------------+-+- HDBC connectivity+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 05/12/08, last update: 05/12/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++module XML.HXQ.DB where++import Database.HDBC+import XML.HXQ.XTree+++sql2xml :: SqlValue -> XTree+sql2xml value =+    case value of+      SqlString s -> XText s+      SqlByteString bs -> XText (show bs)+      SqlWord32 n -> XInt (fromEnum n)+      SqlWord64 n -> XInt (fromEnum n)+      SqlInt32 n -> XText (show n)+      SqlInt64 n -> XText (show n)+      SqlInteger n -> XInt (fromEnum n)+      SqlChar c -> XText [c]+      SqlBool b -> XBool b+      SqlDouble n -> XText (show n)+      SqlRational n -> XText (show n)+      SqlEpochTime n -> XText (show n)+      SqlTimeDiff n -> XText (show n)+      SqlNull -> XText ""+++xml2sql :: XTree -> SqlValue+xml2sql e =+    case e of+      XText s -> SqlString s+      XInt n -> SqlInteger (toInteger n)+      XFloat n -> SqlString (show n)+      XBool n -> SqlBool n+++executeSQL :: Statement -> XSeq -> IO XSeq+executeSQL stmt args+    = do n <- handleSqlError (execute stmt (map xml2sql args))+         result <- handleSqlError (fetchAllRowsAL stmt)+         return (map (\x -> XElem "row" [] 0 (map (\(s,v) -> XElem s [] 0 [sql2xml v]) x)) result)+++prepareSQL :: (IConnection conn) => conn -> String -> IO Statement+prepareSQL db sql = handleSqlError (prepare db sql)

@@ -0,0 +1,352 @@+{-------------------------------------------------------------------------------------+-+- The XQuery Interpreter+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 03/22/08, last update: 05/02/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++{-# OPTIONS_GHC -fth #-}+++module XML.HXQ.Interpreter where++import Control.Monad+import List(sortBy)+import XMLParse(parseDocument)+import System.Console.Readline+import XML.HXQ.Parser+import XML.HXQ.XTree+import XML.HXQ.Optimizer+import XML.HXQ.Compiler+++-- system functions (=, concat, etc)+systemFunctions :: [(String,Int,[XSeq]->XSeq)]+systemFunctions = $(iFunctions)++-- XPath step functions (child, descendant, etc)+pathFunctions :: [(String,Tag->XTree->XSeq)]+pathFunctions = $(pFunctions)++-- run-time bindings of FLOWR variables+type Environment = [(String,XSeq)]++-- a user-defined function is (fname,parameters,body)+type Functions = [(String,[String],Ast)]+++undefv1 = error "Undefined XQuery context (.)"+undefv2 = error "Undefined position()"+undefv3 = error "Undefined last()"+++-- Each XPath predicate must calculate position() and last() from its input XSeq+-- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)+applyPredicates :: [Ast] -> XSeq -> Bool -> Environment -> Functions -> XSeq+applyPredicates [] xs _ _ _ = xs+applyPredicates ((Aint n):preds) xs _ env fncs   -- shortcut that improves laziness+    = applyPredicates preds [xs !! (n-1)] True env fncs+applyPredicates (pred:preds) xs True env fncs    -- top-k like+    | maxPosition pathPosition pred > 0+    = applyPredicates (pred:preds) (take (maxPosition pathPosition pred) xs) False env fncs+applyPredicates (pred:preds) xs _ env fncs+    | containsLast pred         -- blocking: use only when last() is used in the predicate+    = let last = length xs+      in applyPredicates preds+             (foldir (\x i r -> if case eval pred x i last "" env fncs of+                                     [XInt k] -> k == i               -- indexing+                                     b -> conditionTest b+                                then x:r else r) [] xs 1) True env fncs+applyPredicates (pred:preds) xs _ env fncs+    = applyPredicates preds+          (foldir (\x i r -> if case eval pred x i undefv3 "" env fncs of+                                  [XInt k] -> k == i               -- indexing+                                  b -> conditionTest b+                             then x:r else r) [] xs 1) True env fncs+++-- The XQuery interpreter+-- context: context node (XPath .)+-- position: the element position in the parent sequence (XPath position())+-- last: the length of the parent sequence (XPath last())+-- effective_axis: the XPath axis in /axis::tag(exp)+--        (eg, the effective axis of //(A | B) is "descendant_step"+-- env: contains FLOWR variable bindings+-- fncs: user-defined functions+eval :: Ast -> XTree -> Int -> Int -> String -> Environment -> Functions -> XSeq+eval e context position last effective_axis env fncs+  = case e of+      Avar "." -> [ context ]+      Avar v -> findV v env+      Aint n -> [ XInt n ]+      Afloat n -> [ XFloat n ]+      Astring s -> [ XText s ]+      Ast "context" [v,Astring dp,body]+          -> foldr (\x r -> (eval body x position last dp env fncs)++r)+                   [] (eval v context position last effective_axis env fncs)+      Ast "call" [Avar "position"] -> [XInt position]+      Ast "call" [Avar "last"] -> [XInt last]+      Ast "step" [Ast "child_step" [tag, Avar "."]]+          |  effective_axis /= ""+          -> eval (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last "" env fncs+      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)+          -> let ts = map (\(Avar tag) -> tag) tags+             in foldr (\x r -> (applyPredicates predicates (descendant_any_with_tagged_children ts x) True env fncs)++r)+                      [] (eval body context position last effective_axis env fncs)+      Ast "step" ((Ast path_step [Astring tag,body]):predicates)+          |  memV path_step pathFunctions+          -> foldr (\x r -> (applyPredicates predicates ((findV path_step pathFunctions) tag x) True env fncs)++r)+                   [] (eval body context position last effective_axis env fncs)+      Ast "step" [exp]+          -> eval exp context position last effective_axis env fncs+      Ast "step" (exp:predicates)+          -> applyPredicates predicates (eval exp context position last effective_axis env fncs) True env fncs+      Ast "predicate" [condition,body]+          -> applyPredicates [condition] (eval body context position last effective_axis env fncs) True env fncs+      Ast "call" ((Avar fname):args)+          -> case filter (\(n,_,_) -> n == fname || ("fn:"++n) == fname) systemFunctions of+               [(_,len,f)] -> if (length args) == len+                              then f (map (\x -> eval x context position last effective_axis env fncs) args)+                              else error ("Wrong number of arguments in system call: "++fname)+               _ -> case filter (\(n,_,_) -> n == fname) fncs of+                      (_,params,body):_ -> if (length params) == (length args)+                                           then eval body context undefv2 undefv3 ""+                                                    ((zipWith (\p a -> (p,eval a context position last effective_axis env fncs))+                                                              params args)++env) fncs+                                           else error ("Wrong number of arguments in function call: "++fname)+                      _ -> error ("Undefined function: "++fname)+      Ast "construction" [Astring tag,Ast "attributes" [],body]+          -> [ XElem tag [] 0 (eval body context position last effective_axis env fncs) ]+      Ast "construction" [tag,Ast "attributes" al,body]+             -> let alc = map (\(Ast "pair" [a,v])+                                     -> let ac = eval a context position last effective_axis env fncs+                                            vc = eval v context position last effective_axis env fncs+                                        in (qName ac,showXS (text vc))) al+                    ct = eval tag context position last effective_axis env fncs+                    bc = eval body context position last effective_axis env fncs+                in [ XElem (qName ct) alc 0 bc ]+      Ast "let" [Avar var,source,body]+          -> eval body context position last effective_axis+                  ((var,eval source context position last effective_axis env fncs):env) fncs+      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index+          -> foldr (\a r -> (eval body a undefv2 undefv3 "" ((var,[a]):env) fncs)++r)+                   [] (eval source context position last effective_axis env fncs)+      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index+          -> let p = maxPosition (Avar ivar) body+                 ns = if p > 0              -- there is a top-k like restriction+                      then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]+                      else source +             in foldir (\a i r -> (eval body a i undefv3 "" ((var,[a]):(ivar,[XInt i]):env) fncs)++r)+                       [] (eval ns context position last effective_axis env fncs) 1+      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting+          -> [ XElem "" [] 0 (foldl (\r a -> r++[XElem "" [] 0 (text (eval a context position last effective_axis env fncs))])+                                    [XElem "" [] 0 (eval exp context position last effective_axis env fncs)] orderBys) ]+      Ast "sort" (exp:ordList)                   -- blocking+          -> let ce = map (\(XElem _ _ _ xs) -> map (\(XElem _ _ _ ys) -> ys) xs)+                          (eval exp context position last effective_axis env fncs)+                 ordering = foldr (\(Avar ord) r (x:xs) (y:ys)+                                       -> case compareXSeqs (ord == "ascending") x y of+                                            EQ -> r xs ys+                                            o -> o)+                                  (\xs ys -> EQ) ordList+             in concatMap head (sortBy (\(_:xs) (_:ys) -> ordering xs ys) ce)+      _ -> error ("Illegal XQuery: "++(show e))+++-- The monadic applyPredicates that propagates IO state+applyPredicatesM :: [Ast] -> XSeq -> Bool -> Environment -> Functions -> IO XSeq+applyPredicatesM [] xs _ _ _ = return xs+applyPredicatesM ((Aint n):preds) xs _ env fncs   -- shortcut that improves laziness+    = applyPredicatesM preds [xs !! (n-1)] True env fncs+applyPredicatesM (pred:preds) xs True env fncs    -- top-k like+    | maxPosition pathPosition pred > 0+    = applyPredicatesM (pred:preds) (take (maxPosition pathPosition pred) xs) False env fncs+applyPredicatesM (pred:preds) xs _ env fncs+    | containsLast pred         -- blocking: use only when last() is used in the predicate+    = do let last = length xs+         vs <- foldir (\x i r -> do vs <- evalM pred x i last "" env fncs+                                    s <- r+                                    return (if case vs of+                                                 [XInt k] -> k == i               -- indexing+                                                 b -> conditionTest b+                                            then x:s else s))+                      (return []) xs 1+         applyPredicatesM preds vs True env fncs+applyPredicatesM (pred:preds) xs _ env fncs+    = do vs <- foldir (\x i r -> do vs <- evalM pred x i undefv3 "" env fncs+                                    s <- r+                                    return (if case vs of+                                                 [XInt k] -> k == i               -- indexing+                                                 b -> conditionTest b+                                            then x:s else s))+                      (return []) xs 1+         applyPredicatesM preds vs True env fncs+++-- The monadic XQuery interpreter; it is like eval but has plumbing to propagate IO state+evalM :: Ast -> XTree -> Int -> Int -> String -> Environment -> Functions -> IO XSeq+evalM e context position last effective_axis env fncs+  = case e of+      Avar "." -> return [ context ]+      Avar v -> return (findV v env)+      Aint n -> return [ XInt n ]+      Afloat n -> return [ XFloat n ]+      Astring s -> return [ XText s ]+      -- for non-IO XQuery, use the regular eval+      Ast "nonIO" [u] -> return (eval u context position last effective_axis env fncs)+      Ast "context" [v,Astring dp,body]+          -> do vs <- evalM v context position last effective_axis env fncs+                foldr (\x r -> (liftM2 (++)) (evalM body x position last dp env fncs) r)+                      (return []) vs+      Ast "call" [Avar "position"] -> return [XInt position]+      Ast "call" [Avar "last"] -> return [XInt last]+      Ast "step" [Ast "child_step" [tag, Avar "."]]+          |  effective_axis /= ""+          -> evalM (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last "" env fncs+      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)+          -> do vs <- evalM body context position last effective_axis env fncs+                let ts = map (\(Avar tag) -> tag) tags+                foldr (\x r -> (liftM2 (++)) (applyPredicatesM predicates (descendant_any_with_tagged_children ts x) True env fncs) r)+                      (return []) vs+      Ast "step" ((Ast path_step [Astring tag,body]):predicates)+          |  memV path_step pathFunctions+          -> do vs <- evalM body context position last effective_axis env fncs+                foldr (\x r -> (liftM2 (++)) (applyPredicatesM predicates ((findV path_step pathFunctions) tag x) True env fncs) r)+                      (return []) vs+      Ast "step" [exp]+          -> evalM exp context position last effective_axis env fncs+      Ast "step" (exp:predicates)+          -> do vs <- evalM exp context position last effective_axis env fncs+                applyPredicatesM predicates vs True env fncs+      Ast "predicate" [condition,body]+          -> do vs <- evalM body context position last effective_axis env fncs+                applyPredicatesM [condition] vs True env fncs+      Ast "call" [Avar nm,c,t,e]     -- this is the only lazy function+          | elem nm ["if","fn:if"]+          -> do ce <- evalM c context position last effective_axis env fncs+                evalM (if conditionTest ce then t else e) context position last effective_axis env fncs+      Ast "call" ((Avar fname):args)        -- Note: strict function application+          -> case filter (\(n,_,_) -> n == fname || ("fn:"++n) == fname) systemFunctions of+               [(_,len,f)] -> if (length args) == len+                              then (liftM f) (mapM (\x -> evalM x context position last effective_axis env fncs) args)+                              else error ("Wrong number of arguments in system call: "++fname)+               _ -> case filter (\(n,_,_) -> n == fname) fncs of+                      (_,params,body):_ -> if (length params) == (length args)+                                           then do vs <- mapM (\a -> evalM a context position last effective_axis env fncs) args+                                                   evalM body context undefv2 undefv3 ""+                                                             ((zipWith (\p a -> (p,a)) params vs)++env) fncs+                                           else error ("Wrong number of arguments in function call: "++fname)+                      _ -> error ("Undefined function: "++fname)+      Ast "construction" [Astring tag,Ast "attributes" [],body]+          -> do b <- evalM body context position last effective_axis env fncs+                return [ XElem tag [] 0 b ]+      Ast "construction" [tag,Ast "attributes" al,body]+             -> do alc <- mapM (\(Ast "pair" [a,v])+                                     -> do ac <- evalM a context position last effective_axis env fncs+                                           vc <- evalM v context position last effective_axis env fncs+                                           return (qName ac,showXS (text vc))) al+                   ct <- evalM tag context position last effective_axis env fncs+                   bc <- evalM body context position last effective_axis env fncs+                   return [ XElem (qName ct) alc 0 bc ]+      Ast "let" [Avar var,source,body]+          -> do s <- evalM source context position last effective_axis env fncs+                evalM body context position last effective_axis ((var,s):env) fncs+      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index+          -> do vs <- evalM source context position last effective_axis env fncs+                foldr (\a r -> (liftM2 (++)) (evalM body a undefv2 undefv3 "" ((var,[a]):env) fncs) r)+                      (return []) vs+      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index+          -> do let p = maxPosition (Avar ivar) body+                    ns = if p > 0              -- there is a top-k like restriction+                            then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]+                            else source +                vs <- evalM ns context position last effective_axis env fncs+                foldir (\a i r -> (liftM2 (++)) (evalM body a i undefv3 "" ((var,[a]):(ivar,[XInt i]):env) fncs) r)+                       (return []) vs 1+      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting+          -> do vs <- evalM exp context position last effective_axis env fncs+                os <- mapM (\a -> evalM a context position last effective_axis env fncs) orderBys+                return [ XElem "" [] 0 (foldl (\r a -> r++[XElem "" [] 0 (text a)]) [XElem "" [] 0 vs] os) ]+      Ast "sort" (exp:ordList)                   -- blocking+          -> do vs <- evalM exp context position last effective_axis env fncs+                let ce = map (\(XElem _ _ _ xs) -> map (\(XElem _ _ _ ys) -> ys) xs) vs+                    ordering = foldr (\(Avar ord) r (x:xs) (y:ys)+                                       -> case compareXSeqs (ord == "ascending") x y of+                                            EQ -> r xs ys+                                            o -> o)+                                  (\xs ys -> EQ) ordList+                return (concatMap head (sortBy (\(_:xs) (_:ys) -> ordering xs ys) ce))+      _ -> error ("Illegal XQuery: "++(show e))+++-- evaluate from input continuously+evalInput :: (String -> Environment -> Functions -> IO(Environment,Functions)) -> Environment -> Functions -> IO ()+evalInput eval vs fs+    = do let oneline prompt = do line <- readline prompt+                                 case line of+                                   Nothing -> return "quit"+                                   Just t -> if t == ""+                                             then oneline prompt+                                             else return t+             readlines x = do line <- oneline ": "+                              if last line == '}'+                                 then return (x++" "++(init line))+                                 else if line == "quit"+                                      then return line+                                      else readlines (x++" "++line)+         line <- oneline "> "+         stmt <- if head line == '{'+                 then if last line == '}'+                      then return (init (tail line))+                      else readlines (tail line)+                 else return line+         if stmt == "quit"+            then putStrLn "Bye!"+            else do addHistory stmt+                    (nvs,nfs) <- eval (map (\c -> if c=='\"' then '\'' else c) stmt) vs fs+                    evalInput eval nvs nfs+++xqueryE :: String -> Environment -> Functions -> IO (XSeq,Environment,Functions)+xqueryE query variables functions+    = do let asts = parse (scan query)+             fncs = foldr (\e r -> case e of+                                     Ast "function" ((Avar f):b:args) -> (f,map (\(Avar v) -> v) args,optimize b):r+                                     _ -> r) functions asts+         vars <- foldl (\r e -> case e of+                                  Ast "variable" [Avar v,u]+                                      -> do s <- r+                                            uv <- evalM (optimize u) undefv1 undefv2 undefv3 "" s fncs+                                            return ((v,uv):s)+                                  _ -> r) (return variables) asts+         let exprp e = case e of Ast f _ | elem f ["function","variable"] -> True; _ -> False+             (ast,ns) = liftIOSources (concatenateAll (dropWhile exprp asts))+         env <- foldr (\(n,s) r -> case s of+                                     Astring file -> do doc <- readFile file+                                                        env <- r+                                                        return ((n,[materialize (parseDocument doc)]):env)+                                     Avar m -> do env <- r+                                                  return ((n,findV m env):env))+                      (return []) ns+         e <- evalM (optimize ast) undefv1 undefv2 undefv3 "" (env++vars) fncs+         return (e,vars,fncs)+++-- | Evaluate the XQuery using interpreter.+xquery :: String -> IO XSeq+xquery query = do (u,_,_) <- xqueryE query [] []; return u+++-- | Read an XQuery fom a file and run it using the interpreter.+xfile :: String -> IO XSeq+xfile file = do query <- readFile file+                xquery query

@@ -0,0 +1,156 @@+{-------------------------------------------------------------------------------------+-+- Preprocess abstract syntax trees, remove backward steps and optimize+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 05/01/08, last update: 05/01/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++module XML.HXQ.Optimizer(optimize) where++import XML.HXQ.Parser(Ast(..))+import XML.HXQ.XTree+++paths = [ "child_step", "descendant_step", "attribute_step", "attribute_descendant_step" ]+++distinct :: Eq a => [a] -> [a]+distinct = foldl (\r a -> if elem a r then r else r++[a]) []+++-- collect attribute constructions inside element constructions+collect_attributes :: Ast -> (Ast,[Ast])+collect_attributes (Ast "attribute_construction" [attr,value])+    = (Ast "call" [Avar "empty"],[Ast "pair" [attr,value]])+collect_attributes (Ast "call" [Avar "concatenate",x,y])+    = let (cx,ax) = collect_attributes x+          (cy,ay) = collect_attributes y+      in (Ast "call" [Avar "concatenate",cx,cy],ax++ay)+collect_attributes (Ast "step" (e:es))+    = let (ce,ae) = collect_attributes e+      in (Ast "step" (ce:es),ae)+collect_attributes e = (e,[])+++-- does the expression contain a $var/.. ?+parentOfVar :: Ast -> String -> Bool+parentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [Avar x]]]) var = x == var+parentOfVar (Ast "let" [Avar v,s,_]) var | var == v = parentOfVar s var+parentOfVar (Ast "for" [Avar v,Avar i,s,_]) var | var == v || var == i = parentOfVar s var+parentOfVar (Ast _ args) var = or (map (\x -> parentOfVar x var) args)+parentOfVar _ _ = False+++-- replace $var/.. with $nvar+replaceParentOfVar :: Ast -> String -> String -> Ast+replaceParentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [Avar x]]]) var nvar+    | x == var+    = Avar nvar+replaceParentOfVar (Ast "let" [Avar v,s,b]) var nvar | var == v+    = Ast "let" [Avar v,replaceParentOfVar s var nvar,b]+replaceParentOfVar (Ast "for" [Avar v,Avar i,s,b]) var nvar | var == v || var == i+    = Ast "for" [Avar v,Avar i,replaceParentOfVar s var nvar,b]+replaceParentOfVar (Ast f args) var nvar+    = Ast f (map (\x -> replaceParentOfVar x var nvar) args)+replaceParentOfVar e _ _ = e+++-- Rules to extract the parent of an XQuery expression+-- For every XQuery x and predicates p1 ... pn and for s in [tag,*,@attr]:+--    x/s[p1]...[pn]/..   ->  x[s[p1]...[pn]]+--    x//s[p1]...[pn]/..  ->  x//*[s[p1]...[pn]]+removeParent :: Ast -> (Ast,Ast,Bool,Ast)+removeParent (Ast "predicate" [c,x])+         = let (nx,cond,childp,tag) = removeParent x+           in (Ast "predicate" [c,nx],cond,childp,tag)+removeParent (Ast "step" ((Ast "child_step" [tag,x]):preds))+    = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),x,True,tag)+removeParent (Ast "step" ((Ast "descendant_step" [tag,x]):preds))+    = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),+       Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),True,tag)+removeParent (Ast "step" ((Ast "attribute_step" [tag,x]):preds))+    = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),x,False,tag)+removeParent (Ast "step" ((Ast "descendant_attribute_step" [tag,x]):preds))+    = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),+       Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),False,tag)+removeParent (Ast "step" (x:xs))+         = let (nx,cond,childp,tag) = removeParent x+           in (Ast "step" (nx:xs),cond,childp,tag)+removeParent e = error ("Cannot remove this parent step "++(show e))+++tagged_children :: String -> Ast -> [Tag]+tagged_children context (Ast "step" ((Ast "child_step" [Astring tag,Avar "."]):_))+    | context == "."+    = [tag]+tagged_children context (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Avar v):_)]):_))+    | v == context+    = [tag]+tagged_children _ (Ast "step" ((Ast step _):_))+    | elem step paths = []+tagged_children context (Ast _ xs) = concatMap (tagged_children context) xs+tagged_children _ _ = []+++optimize :: Ast -> Ast+-- must be done bottom-up:    /../..+optimize (Ast "step" [Ast "parent_step" [Ast "step" [Ast "parent_step" x]]])+    = let nx = optimize (Ast "step" [Ast "parent_step" x])+      in optimize (Ast "step" [Ast "parent_step" [nx]])+-- get rid of a parent step+optimize (Ast "step" [Ast "parent_step" [x]])+    = let (nx,cond,_,_) = removeParent x+      in Ast "predicate" [optimize nx,optimize cond]+-- remove $var/.. in a let-FLWOR+optimize (Ast "let" [Avar var,source,body])+    | parentOfVar body var+    = let (nx,cond,childp,tag) = removeParent source+      in optimize (Ast "let" [Avar (var++"_parent"),Ast "predicate" [nx,cond],+                              Ast "let" [Avar var,+                                         Ast "step" [ Ast (if childp+                                                           then "child_step"+                                                           else "attribute_step")+                                                      [tag,Avar (var++"_parent")] ],+                                         replaceParentOfVar body var (var++"_parent")]])+-- remove $var/.. from a for-FLWOR+optimize (Ast "for" [Avar var,Avar "$",source,body])+    | parentOfVar body var+    = let (nx,cond,childp,tag) = removeParent source+      in optimize (Ast "for" [Avar (var++"_parent"),Avar "$",Ast "predicate" [nx,cond],+                              Ast "for" [Avar var,Avar "$",+                                         Ast "step" [ Ast (if childp+                                                           then "child_step"+                                                           else "attribute_step")+                                                      [tag,Avar (var++"_parent")] ],+                                         replaceParentOfVar body var (var++"_parent")]])+-- pull out attributes from a general element construction+optimize (Ast "element_construction" [tag,content])+    = let (nc,attrs) = collect_attributes content+      in optimize (Ast "construction" [tag,Ast "attributes" attrs,nc])+-- if //* collect all children tagnames to use descendant_any_with_tagged_children+optimize (Ast "for" [Avar var,i,Ast "step" [Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds)],body])+    | not (null ((tagged_children var body))) || any (not . null . (tagged_children ".")) preds+    = let ctags = distinct ((tagged_children var body)++(concatMap (tagged_children ".") preds))+          tags = map Avar ctags+      in optimize (Ast "for" [Avar var,i,Ast "step" [Ast "step" ((Ast "descendant_any" (path:tags)):preds)],body])+optimize (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds)]):preds2))+    = let ctags = distinct(tag:(concatMap (tagged_children ".") preds))+          tags = map Avar ctags+      in optimize (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Ast "descendant_any" (path:tags)):preds)]):preds2))+optimize (Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds))+    | any (not . null . (tagged_children ".")) preds+    = let ctags = distinct (concatMap (tagged_children ".") preds)+          tags = map Avar ctags+      in optimize (Ast "step" ((Ast "descendant_any" (path:tags)):preds))+-- needs more rules+optimize (Ast n args) = Ast n (map optimize args)+optimize e = e

@@ -0,0 +1,2080 @@+{-# OPTIONS -fglasgow-exts -cpp #-}+module XML.HXQ.Parser where+import Char+#if __GLASGOW_HASKELL__ >= 503+import Data.Array+#else+import Array+#endif+#if __GLASGOW_HASKELL__ >= 503+import GHC.Exts+#else+import GlaExts+#endif++-- parser produced by Happy Version 1.17++newtype HappyAbsSyn  = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = GHC.Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn4 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn4 x = unsafeCoerce# x+{-# INLINE happyIn4 #-}+happyOut4 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut4 x = unsafeCoerce# x+{-# INLINE happyOut4 #-}+happyIn5 :: (Ast) -> (HappyAbsSyn )+happyIn5 x = unsafeCoerce# x+{-# INLINE happyIn5 #-}+happyOut5 :: (HappyAbsSyn ) -> (Ast)+happyOut5 x = unsafeCoerce# x+{-# INLINE happyOut5 #-}+happyIn6 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn6 x = unsafeCoerce# x+{-# INLINE happyIn6 #-}+happyOut6 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut6 x = unsafeCoerce# x+{-# INLINE happyOut6 #-}+happyIn7 :: (Ast) -> (HappyAbsSyn )+happyIn7 x = unsafeCoerce# x+{-# INLINE happyIn7 #-}+happyOut7 :: (HappyAbsSyn ) -> (Ast)+happyOut7 x = unsafeCoerce# x+{-# INLINE happyOut7 #-}+happyIn8 :: (Ast) -> (HappyAbsSyn )+happyIn8 x = unsafeCoerce# x+{-# INLINE happyIn8 #-}+happyOut8 :: (HappyAbsSyn ) -> (Ast)+happyOut8 x = unsafeCoerce# x+{-# INLINE happyOut8 #-}+happyIn9 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn9 x = unsafeCoerce# x+{-# INLINE happyIn9 #-}+happyOut9 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut9 x = unsafeCoerce# x+{-# INLINE happyOut9 #-}+happyIn10 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn10 x = unsafeCoerce# x+{-# INLINE happyIn10 #-}+happyOut10 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut10 x = unsafeCoerce# x+{-# INLINE happyOut10 #-}+happyIn11 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn11 x = unsafeCoerce# x+{-# INLINE happyIn11 #-}+happyOut11 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut11 x = unsafeCoerce# x+{-# INLINE happyOut11 #-}+happyIn12 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn12 x = unsafeCoerce# x+{-# INLINE happyIn12 #-}+happyOut12 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut12 x = unsafeCoerce# x+{-# INLINE happyOut12 #-}+happyIn13 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn13 x = unsafeCoerce# x+{-# INLINE happyIn13 #-}+happyOut13 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut13 x = unsafeCoerce# x+{-# INLINE happyOut13 #-}+happyIn14 :: (( Ast -> Ast, Ast -> Ast )) -> (HappyAbsSyn )+happyIn14 x = unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn ) -> (( Ast -> Ast, Ast -> Ast ))+happyOut14 x = unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: (( [ Ast ], [ Ast ] )) -> (HappyAbsSyn )+happyIn15 x = unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn ) -> (( [ Ast ], [ Ast ] ))+happyOut15 x = unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: (Ast) -> (HappyAbsSyn )+happyIn16 x = unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> (Ast)+happyOut16 x = unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: (Ast) -> (HappyAbsSyn )+happyIn17 x = unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> (Ast)+happyOut17 x = unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (Ast) -> (HappyAbsSyn )+happyIn18 x = unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> (Ast)+happyOut18 x = unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn19 x = unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut19 x = unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn20 x = unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut20 x = unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: ([ Ast ]) -> (HappyAbsSyn )+happyIn21 x = unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> ([ Ast ])+happyOut21 x = unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (Ast) -> (HappyAbsSyn )+happyIn22 x = unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> (Ast)+happyOut22 x = unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn23 x = unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut23 x = unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: (Ast -> Ast) -> (HappyAbsSyn )+happyIn24 x = unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> (Ast -> Ast)+happyOut24 x = unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: (String -> Ast -> [ Ast ]) -> (HappyAbsSyn )+happyIn25 x = unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> (String -> Ast -> [ Ast ])+happyOut25 x = unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (String -> Ast -> Ast) -> (HappyAbsSyn )+happyIn26 x = unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> (String -> Ast -> Ast)+happyOut26 x = unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: (String -> Ast -> Ast) -> (HappyAbsSyn )+happyIn27 x = unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> (String -> Ast -> Ast)+happyOut27 x = unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyInTok :: Token -> (HappyAbsSyn )+happyInTok x = unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> Token+happyOutTok x = unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\xbe\x00\xbe\x00\x00\x00\x00\x00\x74\x02\x70\x00\x00\x00\x00\x00\xeb\xff\x00\x00\xfd\xff\x00\x00\x00\x00\x69\x01\x69\x01\xfa\x00\x82\x00\xfa\x00\xfa\x00\x00\x00\x70\x01\xfa\x00\x67\x01\x67\x01\x1c\x00\x16\x00\x37\x00\x84\x01\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xff\x47\x01\x00\x00\x3b\x00\x4f\x01\x46\x01\xff\xff\xfd\xff\x4d\x01\xfa\x00\x7d\x01\x4b\x01\xfa\x00\x7b\x01\x0c\x01\x11\x01\xe0\xff\x0f\x01\x00\x00\xf9\x00\x00\x00\x00\x00\x74\x02\x29\x00\x00\x00\x5a\x01\xf4\xff\xef\xff\x2b\x01\x00\x00\xfa\x00\x4d\x00\x24\x00\x00\x00\x02\x01\xed\x00\xed\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\x90\x02\x90\x02\x90\x02\xc2\x02\x90\x02\xa9\x02\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x00\x00\x00\x00\x00\x00\x00\x00\x25\x01\x25\x01\xda\x02\x74\x02\x04\x01\x00\x01\x2c\x01\xee\x00\x00\x00\x19\x00\xfa\x00\x0e\x00\xfb\xff\xe2\x00\x00\x00\x00\x00\x16\x01\x37\x00\x5b\x00\x00\x00\xa2\x01\x00\x00\xd5\x00\xfa\x00\xfa\x00\xfa\x00\x00\x00\xfa\x00\xdb\x00\xfe\x00\xfa\x00\xd2\x00\xd2\x00\xfa\x00\xfa\x00\x1e\x02\x05\x01\xfa\x00\xff\x01\x03\x01\xc6\x00\x08\x00\x00\x00\xd0\x00\xf0\x00\xb2\x00\x00\x00\x04\x00\xfa\x00\x00\x00\x00\x00\xeb\x00\x5f\x00\x00\x00\xe7\x00\x5c\x00\x74\x02\xc2\x00\xb7\x00\x74\x02\x09\x00\xcc\x00\x74\x02\x7f\x01\x74\x02\x74\x02\xde\xff\x00\x00\xda\x00\x37\x00\xda\x00\xc3\x00\x50\x00\x00\x00\xfa\x00\x9f\x00\x00\x00\x00\x00\xfa\x00\xfa\x00\x74\x02\x34\x01\xaa\x00\xc0\x00\x26\x00\x00\x00\x00\x00\xca\x00\xfa\x00\x8f\x00\xfa\x00\xfa\xff\xfa\x00\x00\x00\xfa\x00\xfa\x00\x00\x00\xfa\x00\x00\x00\xfa\x00\x74\x02\x02\x00\x00\x00\xba\x00\xfa\x00\xb8\x00\x7b\x00\x0c\x00\xfe\xff\x74\x02\x74\x02\x58\x02\xfa\x00\x00\x00\x74\x02\x90\x00\x74\x02\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x34\x01\xfa\x00\x3b\x02\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xe0\x01\x00\x00\xc1\x01\x00\x00\x74\x02\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\xa4\x00\x0d\x01\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x9b\x00\x79\x00\x5a\x06\x9c\x03\x4d\x06\x40\x06\x00\x00\x00\x00\x33\x06\x73\x00\x67\x00\x00\x00\x00\x00\x15\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\xa0\x00\x87\x03\x98\x00\x00\x00\x26\x06\x00\x00\x00\x00\x19\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x0c\x06\x12\x01\xbd\x00\x00\x00\x86\x00\x6b\x00\x5d\x00\xff\x05\xf2\x05\xe5\x05\xd8\x05\xcb\x05\xbe\x05\xb1\x05\xa4\x05\x97\x05\x8a\x05\x7d\x05\x70\x05\x63\x05\x56\x05\x49\x05\x3c\x05\x2f\x05\x22\x05\x15\x05\x08\x05\xfb\x04\xee\x04\xe1\x04\xd4\x04\xc7\x04\xba\x04\xad\x04\xa0\x04\x93\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x72\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x71\x00\x86\x04\x79\x04\x6c\x04\x00\x00\x5f\x04\x00\x00\x00\x00\x52\x04\x60\x00\x5a\x00\x45\x04\x5d\x03\x00\x00\x00\x00\x48\x03\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x38\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x03\x00\x00\x00\x00\x00\x00\x1e\x03\x2b\x04\x00\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x04\x2b\x00\x11\x04\x00\x00\x04\x04\x00\x00\xf7\x03\xea\x03\x00\x00\x11\x03\x00\x00\xfc\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x03\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x00\x00\x00\x00\x00\x00\x07\x00\xb6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\x00\x00\x00\x00\x00\x00\x8e\xff\xfa\xff\xbd\xff\xed\xff\xee\xff\x00\x00\xef\xff\x9e\xff\x93\xff\x91\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\xff\x00\x00\x8d\xff\xf4\xff\xcc\xff\xcb\xff\xcd\xff\x00\x00\xfe\xff\xfd\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\xff\x00\x00\xc8\xff\xce\xff\xac\xff\xcf\xff\xd0\xff\xca\xff\x00\x00\x8b\xff\x00\x00\x00\x00\x00\x00\x9c\xff\x9a\xff\x00\x00\x00\x00\x00\x00\xb1\xff\xbb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xff\xd2\xff\xd3\xff\xd4\xff\xd5\xff\xd6\xff\xd7\xff\xd8\xff\xd9\xff\xda\xff\xdb\xff\xdc\xff\xdd\xff\xde\xff\xdf\xff\xe0\xff\xe1\xff\xe2\xff\xe3\xff\xe4\xff\xe5\xff\xe6\xff\xe7\xff\xe8\xff\xe9\xff\xea\xff\xeb\xff\xec\xff\xbe\xff\xc5\xff\xc6\xff\x00\x00\x00\x00\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\xa9\xff\x98\xff\x00\x00\x00\x00\x94\xff\x00\x00\x99\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xff\x00\x00\xab\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x89\xff\x00\x00\x00\x00\xfc\xff\xfb\xff\x00\x00\x00\x00\x8a\xff\xb4\xff\x00\x00\x00\x00\xb5\xff\x00\x00\x00\x00\xc0\xff\x00\x00\x00\x00\xc4\xff\x00\x00\x00\x00\xc9\xff\x00\x00\xf1\xff\xf2\xff\x00\x00\x92\xff\x96\xff\x00\x00\x97\xff\x00\x00\x00\x00\xa3\xff\x00\x00\x00\x00\xa4\xff\xa5\xff\x00\x00\x00\x00\xf3\xff\xb6\xff\xbc\xff\x00\x00\x00\x00\xaa\xff\xb2\xff\x95\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\xae\xff\x00\x00\xad\xff\x00\x00\xf9\xff\x00\x00\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\xff\xc3\xff\x00\x00\x00\x00\xa0\xff\xf0\xff\x00\x00\xc2\xff\xa6\xff\xb3\xff\x00\x00\xba\xff\xb8\xff\xb7\xff\xb6\xff\x00\x00\x00\x00\xa1\xff\xb0\xff\xaf\xff\xf5\xff\x00\x00\x00\x00\xf7\xff\x00\x00\x9f\xff\xc1\xff\xb9\xff\xf8\xff"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x02\x00\x03\x00\x04\x00\x07\x00\x1a\x00\x0b\x00\x0d\x00\x09\x00\x0a\x00\x0c\x00\x2d\x00\x0a\x00\x2d\x00\x0a\x00\x10\x00\x11\x00\x12\x00\x0a\x00\x0c\x00\x43\x00\x03\x00\x0d\x00\x18\x00\x0c\x00\x0b\x00\x49\x00\x0e\x00\x0f\x00\x2e\x00\x40\x00\x09\x00\x40\x00\x0b\x00\x2e\x00\x38\x00\x0b\x00\x09\x00\x27\x00\x0b\x00\x39\x00\x0c\x00\x2b\x00\x2c\x00\x2e\x00\x39\x00\x03\x00\x0b\x00\x2e\x00\x18\x00\x0c\x00\x0a\x00\x35\x00\x36\x00\x2e\x00\x3c\x00\x3b\x00\x3a\x00\x2e\x00\x3c\x00\x18\x00\x02\x00\x03\x00\x04\x00\x09\x00\x42\x00\x48\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x44\x00\x12\x00\x3c\x00\x10\x00\x11\x00\x12\x00\x35\x00\x36\x00\x37\x00\x48\x00\x3c\x00\x18\x00\x2e\x00\x14\x00\x09\x00\x2e\x00\x3c\x00\x35\x00\x36\x00\x37\x00\x0c\x00\x03\x00\x45\x00\x12\x00\x03\x00\x48\x00\x27\x00\x03\x00\x09\x00\x08\x00\x2b\x00\x2c\x00\x0c\x00\x45\x00\x03\x00\x0c\x00\x48\x00\x12\x00\x03\x00\x08\x00\x35\x00\x36\x00\x07\x00\x3c\x00\x03\x00\x3a\x00\x03\x00\x3c\x00\x3d\x00\x42\x00\x07\x00\x44\x00\x03\x00\x42\x00\x2e\x00\x44\x00\x07\x00\x46\x00\x47\x00\x48\x00\x02\x00\x03\x00\x04\x00\x3a\x00\x3b\x00\x3c\x00\x2e\x00\x09\x00\x0a\x00\x2e\x00\x41\x00\x42\x00\x0a\x00\x44\x00\x10\x00\x11\x00\x12\x00\x3a\x00\x11\x00\x3c\x00\x02\x00\x03\x00\x18\x00\x2b\x00\x2c\x00\x42\x00\x03\x00\x44\x00\x30\x00\x14\x00\x07\x00\x03\x00\x00\x00\x01\x00\x09\x00\x03\x00\x04\x00\x27\x00\x06\x00\x13\x00\x14\x00\x2b\x00\x2c\x00\x13\x00\x14\x00\x0d\x00\x0e\x00\x0f\x00\x3e\x00\x3f\x00\x12\x00\x35\x00\x36\x00\x15\x00\x16\x00\x17\x00\x3a\x00\x2d\x00\x3c\x00\x44\x00\x02\x00\x03\x00\x04\x00\x0b\x00\x42\x00\x0b\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x0e\x00\x0f\x00\x10\x00\x10\x00\x11\x00\x12\x00\x07\x00\x01\x00\x44\x00\x03\x00\x04\x00\x18\x00\x06\x00\x2e\x00\x03\x00\x1a\x00\x3c\x00\x03\x00\x1a\x00\x0d\x00\x0e\x00\x0f\x00\x07\x00\x16\x00\x12\x00\x2d\x00\x27\x00\x15\x00\x16\x00\x17\x00\x2b\x00\x2c\x00\x15\x00\x16\x00\x17\x00\x15\x00\x16\x00\x17\x00\x2f\x00\x0b\x00\x35\x00\x36\x00\x03\x00\x0b\x00\x45\x00\x3a\x00\x09\x00\x3c\x00\x3d\x00\x02\x00\x03\x00\x04\x00\x2f\x00\x42\x00\x3b\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x15\x00\x16\x00\x17\x00\x10\x00\x11\x00\x12\x00\x0a\x00\x01\x00\x0a\x00\x03\x00\x04\x00\x18\x00\x06\x00\x16\x00\x03\x00\x44\x00\x3c\x00\x03\x00\x44\x00\x0d\x00\x0e\x00\x0f\x00\x07\x00\x3c\x00\x12\x00\x32\x00\x27\x00\x15\x00\x16\x00\x17\x00\x2b\x00\x2c\x00\x15\x00\x16\x00\x17\x00\x15\x00\x16\x00\x17\x00\x01\x00\x2e\x00\x35\x00\x36\x00\x44\x00\x2e\x00\x31\x00\x3a\x00\x3c\x00\x3c\x00\x12\x00\x13\x00\x14\x00\x15\x00\x2f\x00\x42\x00\x2e\x00\x44\x00\x2e\x00\x46\x00\x47\x00\x48\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x05\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x3b\x00\x33\x00\x34\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x06\x00\x0b\x00\x3c\x00\x0b\x00\x3c\x00\x44\x00\x3c\x00\x45\x00\x09\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x08\x00\x44\x00\x3c\x00\x44\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\xff\xff\x27\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\x0b\x00\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++happyTable :: HappyAddr+happyTable = HappyA# "\x00\x00\x0e\x00\x0f\x00\x10\x00\x41\x00\x43\x00\x2c\x00\xee\x00\x11\x00\xa8\x00\xfd\x00\xd6\x00\xe7\x00\x9c\x00\xe5\x00\x12\x00\x13\x00\x14\x00\xaf\x00\x05\x01\x26\x00\xfe\x00\xda\x00\x15\x00\xfe\x00\x2f\x00\xff\xff\xc6\x00\x08\x00\x94\x00\xd7\x00\x2b\x00\x9d\x00\x2c\x00\x94\x00\x44\x00\xc8\x00\x2e\x00\x16\x00\x2f\x00\x95\x00\xf5\x00\x17\x00\x18\x00\x99\x00\x96\x00\xf0\x00\x88\x00\xe8\x00\x15\x00\xf3\x00\x98\x00\x19\x00\x1a\x00\x99\x00\x2d\x00\x42\x00\x1b\x00\x99\x00\x1c\x00\x15\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x1e\x00\xef\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\x1f\x00\x14\x00\x30\x00\x12\x00\x13\x00\x14\x00\x89\x00\x8a\x00\xc9\x00\xdb\x00\x2d\x00\x15\x00\x99\x00\x92\x00\x11\x00\x99\x00\x30\x00\x89\x00\x8a\x00\x8b\x00\xd3\x00\xb6\x00\xca\x00\x14\x00\x30\x00\xcb\x00\x16\x00\xb7\x00\x11\x00\x81\x00\x17\x00\x18\x00\xde\x00\x8c\x00\x30\x00\xe0\x00\x8d\x00\x14\x00\x32\x00\x31\x00\x19\x00\x1a\x00\x82\x00\x1c\x00\xbf\x00\x1b\x00\x32\x00\x1c\x00\x1d\x00\x1e\x00\x33\x00\x1f\x00\x32\x00\x1e\x00\x99\x00\x1f\x00\x3c\x00\x20\x00\x21\x00\x22\x00\x0e\x00\x0f\x00\x10\x00\x8f\x00\x90\x00\x1c\x00\x99\x00\x11\x00\x3b\x00\x99\x00\x91\x00\x1e\x00\x83\x00\x1f\x00\x12\x00\x13\x00\x14\x00\xc3\x00\x99\x00\x1c\x00\xe2\x00\xe3\x00\x15\x00\x46\x00\x47\x00\x1e\x00\x32\x00\x1f\x00\x48\x00\x92\x00\x3d\x00\xa8\x00\x22\x00\x23\x00\x44\x00\x03\x00\x04\x00\x16\x00\x05\x00\xa5\x00\x3f\x00\x17\x00\x18\x00\x3e\x00\x3f\x00\x06\x00\x07\x00\x08\x00\x27\x00\x28\x00\x09\x00\x19\x00\x1a\x00\x0a\x00\x0b\x00\x0c\x00\x1b\x00\xfa\x00\x1c\x00\x1f\x00\x0e\x00\x0f\x00\x10\x00\x00\x01\x1e\x00\xe6\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\x85\x00\x08\x00\x86\x00\x12\x00\x13\x00\x14\x00\x41\x00\xaa\x00\x1f\x00\x03\x00\x04\x00\x15\x00\x05\x00\xf5\x00\x03\x00\xf4\x00\xd1\x00\x03\x00\xd4\x00\x06\x00\x07\x00\x08\x00\x41\x00\xd9\x00\x09\x00\xdc\x00\x16\x00\x0a\x00\x0b\x00\x0c\x00\x17\x00\x18\x00\xd4\x00\x0b\x00\x0c\x00\xc1\x00\x0b\x00\x0c\x00\xdd\x00\xdf\x00\x19\x00\x1a\x00\x03\x00\xe1\x00\xac\x00\x1b\x00\xad\x00\x1c\x00\x1d\x00\x0e\x00\x0f\x00\x10\x00\xae\x00\x1e\x00\x42\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\xc3\x00\x0b\x00\x0c\x00\x12\x00\x13\x00\x14\x00\xb0\x00\x02\x00\xb3\x00\x03\x00\x04\x00\x15\x00\x05\x00\xba\x00\x03\x00\x1f\x00\xbb\x00\x03\x00\x1f\x00\x06\x00\x07\x00\x08\x00\x41\x00\xc5\x00\x09\x00\xcc\x00\x16\x00\x0a\x00\x0b\x00\x0c\x00\x17\x00\x18\x00\x8d\x00\x0b\x00\x0c\x00\x29\x00\x0b\x00\x0c\x00\xcd\x00\x94\x00\x19\x00\x1a\x00\x1f\x00\x9e\x00\x85\x00\x1b\x00\x9b\x00\x1c\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x9f\x00\x1e\x00\x94\x00\x1f\x00\x9e\x00\x20\x00\x21\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x97\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x42\x00\xf7\x00\xf8\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xd8\x00\xa0\x00\xa2\x00\xa3\x00\xa5\x00\x1f\x00\xaa\x00\x25\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xc1\x00\x1f\x00\x36\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x07\x01\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x02\x01\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xb1\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xb4\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x04\x01\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xfc\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x00\x00\x61\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x03\x00\x38\x00\xe8\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xe9\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xce\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\xcf\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xd1\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xb1\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xb4\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xc5\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xa6\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\x39\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x02\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x04\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xf8\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xfa\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x00\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xea\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xeb\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xec\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xef\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xf1\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xcd\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xe1\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xb5\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xb8\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbb\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbc\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbd\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbe\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x64\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x65\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x66\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x67\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x68\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x69\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6a\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6c\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6d\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6e\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6f\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x70\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x71\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x72\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x73\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x74\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x75\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x76\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x77\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x78\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x79\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7a\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7c\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7d\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7e\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7f\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x80\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x91\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xa0\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xa3\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x34\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x36\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x37\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x3b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++happyReduceArr = array (1, 118) [+	(1 , happyReduce_1),+	(2 , happyReduce_2),+	(3 , happyReduce_3),+	(4 , happyReduce_4),+	(5 , happyReduce_5),+	(6 , happyReduce_6),+	(7 , happyReduce_7),+	(8 , happyReduce_8),+	(9 , happyReduce_9),+	(10 , happyReduce_10),+	(11 , happyReduce_11),+	(12 , happyReduce_12),+	(13 , happyReduce_13),+	(14 , happyReduce_14),+	(15 , happyReduce_15),+	(16 , happyReduce_16),+	(17 , happyReduce_17),+	(18 , happyReduce_18),+	(19 , happyReduce_19),+	(20 , happyReduce_20),+	(21 , happyReduce_21),+	(22 , happyReduce_22),+	(23 , happyReduce_23),+	(24 , happyReduce_24),+	(25 , happyReduce_25),+	(26 , happyReduce_26),+	(27 , happyReduce_27),+	(28 , happyReduce_28),+	(29 , happyReduce_29),+	(30 , happyReduce_30),+	(31 , happyReduce_31),+	(32 , happyReduce_32),+	(33 , happyReduce_33),+	(34 , happyReduce_34),+	(35 , happyReduce_35),+	(36 , happyReduce_36),+	(37 , happyReduce_37),+	(38 , happyReduce_38),+	(39 , happyReduce_39),+	(40 , happyReduce_40),+	(41 , happyReduce_41),+	(42 , happyReduce_42),+	(43 , happyReduce_43),+	(44 , happyReduce_44),+	(45 , happyReduce_45),+	(46 , happyReduce_46),+	(47 , happyReduce_47),+	(48 , happyReduce_48),+	(49 , happyReduce_49),+	(50 , happyReduce_50),+	(51 , happyReduce_51),+	(52 , happyReduce_52),+	(53 , happyReduce_53),+	(54 , happyReduce_54),+	(55 , happyReduce_55),+	(56 , happyReduce_56),+	(57 , happyReduce_57),+	(58 , happyReduce_58),+	(59 , happyReduce_59),+	(60 , happyReduce_60),+	(61 , happyReduce_61),+	(62 , happyReduce_62),+	(63 , happyReduce_63),+	(64 , happyReduce_64),+	(65 , happyReduce_65),+	(66 , happyReduce_66),+	(67 , happyReduce_67),+	(68 , happyReduce_68),+	(69 , happyReduce_69),+	(70 , happyReduce_70),+	(71 , happyReduce_71),+	(72 , happyReduce_72),+	(73 , happyReduce_73),+	(74 , happyReduce_74),+	(75 , happyReduce_75),+	(76 , happyReduce_76),+	(77 , happyReduce_77),+	(78 , happyReduce_78),+	(79 , happyReduce_79),+	(80 , happyReduce_80),+	(81 , happyReduce_81),+	(82 , happyReduce_82),+	(83 , happyReduce_83),+	(84 , happyReduce_84),+	(85 , happyReduce_85),+	(86 , happyReduce_86),+	(87 , happyReduce_87),+	(88 , happyReduce_88),+	(89 , happyReduce_89),+	(90 , happyReduce_90),+	(91 , happyReduce_91),+	(92 , happyReduce_92),+	(93 , happyReduce_93),+	(94 , happyReduce_94),+	(95 , happyReduce_95),+	(96 , happyReduce_96),+	(97 , happyReduce_97),+	(98 , happyReduce_98),+	(99 , happyReduce_99),+	(100 , happyReduce_100),+	(101 , happyReduce_101),+	(102 , happyReduce_102),+	(103 , happyReduce_103),+	(104 , happyReduce_104),+	(105 , happyReduce_105),+	(106 , happyReduce_106),+	(107 , happyReduce_107),+	(108 , happyReduce_108),+	(109 , happyReduce_109),+	(110 , happyReduce_110),+	(111 , happyReduce_111),+	(112 , happyReduce_112),+	(113 , happyReduce_113),+	(114 , happyReduce_114),+	(115 , happyReduce_115),+	(116 , happyReduce_116),+	(117 , happyReduce_117),+	(118 , happyReduce_118)+	]++happy_n_terms = 74 :: Int+happy_n_nonterms = 24 :: Int++happyReduce_1 = happySpecReduce_1  0# happyReduction_1+happyReduction_1 happy_x_1+	 =  case happyOut5 happy_x_1 of { happy_var_1 -> +	happyIn4+		 ([happy_var_1]+	)}++happyReduce_2 = happySpecReduce_2  0# happyReduction_2+happyReduction_2 happy_x_2+	happy_x_1+	 =  case happyOut5 happy_x_1 of { happy_var_1 -> +	happyIn4+		 ([happy_var_1]+	)}++happyReduce_3 = happySpecReduce_3  0# happyReduction_3+happyReduction_3 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut4 happy_x_1 of { happy_var_1 -> +	case happyOut5 happy_x_3 of { happy_var_3 -> +	happyIn4+		 (happy_var_1++[happy_var_3]+	)}}++happyReduce_4 = happyReduce 4# 0# happyReduction_4+happyReduction_4 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut4 happy_x_1 of { happy_var_1 -> +	case happyOut5 happy_x_3 of { happy_var_3 -> +	happyIn4+		 (happy_var_1++[happy_var_3]+	) `HappyStk` happyRest}}++happyReduce_5 = happySpecReduce_1  1# happyReduction_5+happyReduction_5 happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	happyIn5+		 (happy_var_1+	)}++happyReduce_6 = happyReduce 5# 1# happyReduction_6+happyReduction_6 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut7 happy_x_3 of { happy_var_3 -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn5+		 (Ast "variable" [happy_var_3,happy_var_5]+	) `HappyStk` happyRest}}++happyReduce_7 = happyReduce 9# 1# happyReduction_7+happyReduction_7 (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 happyOut6 happy_x_5 of { happy_var_5 -> +	case happyOut8 happy_x_8 of { happy_var_8 -> +	happyIn5+		 (Ast "function" ([Avar happy_var_3,happy_var_8]++happy_var_5)+	) `HappyStk` happyRest}}}++happyReduce_8 = happyReduce 8# 1# happyReduction_8+happyReduction_8 (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 happyOut8 happy_x_7 of { happy_var_7 -> +	happyIn5+		 (Ast "function" [Avar happy_var_3,happy_var_7]+	) `HappyStk` happyRest}}++happyReduce_9 = happySpecReduce_1  2# happyReduction_9+happyReduction_9 happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	happyIn6+		 ([happy_var_1]+	)}++happyReduce_10 = happySpecReduce_3  2# happyReduction_10+happyReduction_10 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 -> +	happyIn6+		 (happy_var_1++[happy_var_3]+	)}}++happyReduce_11 = happySpecReduce_1  3# happyReduction_11+happyReduction_11 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Variable happy_var_1) -> +	happyIn7+		 (Avar happy_var_1+	)}++happyReduce_12 = happyReduce 5# 4# happyReduction_12+happyReduction_12 (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 happyOut13 happy_x_2 of { happy_var_2 -> +	case happyOut14 happy_x_3 of { happy_var_3 -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn8+		 ((snd happy_var_3) (happy_var_1 (happy_var_2 ((fst happy_var_3) happy_var_5)))+	) `HappyStk` happyRest}}}}++happyReduce_13 = happyReduce 4# 4# happyReduction_13+happyReduction_13 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut11 happy_x_2 of { happy_var_2 -> +	case happyOut8 happy_x_4 of { happy_var_4 -> +	happyIn8+		 (call "some" [happy_var_2 happy_var_4]+	) `HappyStk` happyRest}}++happyReduce_14 = happyReduce 4# 4# happyReduction_14+happyReduction_14 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut11 happy_x_2 of { happy_var_2 -> +	case happyOut8 happy_x_4 of { happy_var_4 -> +	happyIn8+		 (call "not" [call "some" [happy_var_2 (call "not" [happy_var_4])]]+	) `HappyStk` happyRest}}++happyReduce_15 = happyReduce 6# 4# happyReduction_15+happyReduction_15 (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 happyOut8 happy_x_2 of { happy_var_2 -> +	case happyOut8 happy_x_4 of { happy_var_4 -> +	case happyOut8 happy_x_6 of { happy_var_6 -> +	happyIn8+		 (call "if" [happy_var_2,happy_var_4,happy_var_6]+	) `HappyStk` happyRest}}}++happyReduce_16 = happySpecReduce_1  4# happyReduction_16+happyReduction_16 happy_x_1+	 =  case happyOut22 happy_x_1 of { happy_var_1 -> +	happyIn8+		 (happy_var_1+	)}++happyReduce_17 = happySpecReduce_1  4# happyReduction_17+happyReduction_17 happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	happyIn8+		 (happy_var_1+	)}++happyReduce_18 = happySpecReduce_1  4# happyReduction_18+happyReduction_18 happy_x_1+	 =  case happyOut17 happy_x_1 of { happy_var_1 -> +	happyIn8+		 (happy_var_1+	)}++happyReduce_19 = happySpecReduce_3  4# happyReduction_19+happyReduction_19 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "to" [happy_var_1,happy_var_3]+	)}}++happyReduce_20 = happySpecReduce_3  4# happyReduction_20+happyReduction_20 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "+" [happy_var_1,happy_var_3]+	)}}++happyReduce_21 = happySpecReduce_3  4# happyReduction_21+happyReduction_21 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "-" [happy_var_1,happy_var_3]+	)}}++happyReduce_22 = happySpecReduce_3  4# happyReduction_22+happyReduction_22 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "*" [happy_var_1,happy_var_3]+	)}}++happyReduce_23 = happySpecReduce_3  4# happyReduction_23+happyReduction_23 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "div" [happy_var_1,happy_var_3]+	)}}++happyReduce_24 = happySpecReduce_3  4# happyReduction_24+happyReduction_24 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "idiv" [happy_var_1,happy_var_3]+	)}}++happyReduce_25 = happySpecReduce_3  4# happyReduction_25+happyReduction_25 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "mod" [happy_var_1,happy_var_3]+	)}}++happyReduce_26 = happySpecReduce_3  4# happyReduction_26+happyReduction_26 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "=" [happy_var_1,happy_var_3]+	)}}++happyReduce_27 = happySpecReduce_3  4# happyReduction_27+happyReduction_27 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "!=" [happy_var_1,happy_var_3]+	)}}++happyReduce_28 = happySpecReduce_3  4# happyReduction_28+happyReduction_28 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "<" [happy_var_1,happy_var_3]+	)}}++happyReduce_29 = happySpecReduce_3  4# happyReduction_29+happyReduction_29 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "<=" [happy_var_1,happy_var_3]+	)}}++happyReduce_30 = happySpecReduce_3  4# happyReduction_30+happyReduction_30 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call ">" [happy_var_1,happy_var_3]+	)}}++happyReduce_31 = happySpecReduce_3  4# happyReduction_31+happyReduction_31 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call ">=" [happy_var_1,happy_var_3]+	)}}++happyReduce_32 = happySpecReduce_3  4# happyReduction_32+happyReduction_32 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "<<" [happy_var_1,happy_var_3]+	)}}++happyReduce_33 = happySpecReduce_3  4# happyReduction_33+happyReduction_33 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call ">>" [happy_var_1,happy_var_3]+	)}}++happyReduce_34 = happySpecReduce_3  4# happyReduction_34+happyReduction_34 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "is" [happy_var_1,happy_var_3]+	)}}++happyReduce_35 = happySpecReduce_3  4# happyReduction_35+happyReduction_35 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "eq" [happy_var_1,happy_var_3]+	)}}++happyReduce_36 = happySpecReduce_3  4# happyReduction_36+happyReduction_36 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "ne" [happy_var_1,happy_var_3]+	)}}++happyReduce_37 = happySpecReduce_3  4# happyReduction_37+happyReduction_37 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "lt" [happy_var_1,happy_var_3]+	)}}++happyReduce_38 = happySpecReduce_3  4# happyReduction_38+happyReduction_38 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "le" [happy_var_1,happy_var_3]+	)}}++happyReduce_39 = happySpecReduce_3  4# happyReduction_39+happyReduction_39 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "gt" [happy_var_1,happy_var_3]+	)}}++happyReduce_40 = happySpecReduce_3  4# happyReduction_40+happyReduction_40 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "ge" [happy_var_1,happy_var_3]+	)}}++happyReduce_41 = happySpecReduce_3  4# happyReduction_41+happyReduction_41 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "and" [happy_var_1,happy_var_3]+	)}}++happyReduce_42 = happySpecReduce_3  4# happyReduction_42+happyReduction_42 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "or" [happy_var_1,happy_var_3]+	)}}++happyReduce_43 = happySpecReduce_3  4# happyReduction_43+happyReduction_43 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "not" [happy_var_1,happy_var_3]+	)}}++happyReduce_44 = happySpecReduce_3  4# happyReduction_44+happyReduction_44 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "union" [happy_var_1,happy_var_3]+	)}}++happyReduce_45 = happySpecReduce_3  4# happyReduction_45+happyReduction_45 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "intersect" [happy_var_1,happy_var_3]+	)}}++happyReduce_46 = happySpecReduce_3  4# happyReduction_46+happyReduction_46 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn8+		 (call "except" [happy_var_1,happy_var_3]+	)}}++happyReduce_47 = happySpecReduce_2  4# happyReduction_47+happyReduction_47 happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_2 of { happy_var_2 -> +	happyIn8+		 (call "uplus" [happy_var_2]+	)}++happyReduce_48 = happySpecReduce_2  4# happyReduction_48+happyReduction_48 happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_2 of { happy_var_2 -> +	happyIn8+		 (call "uminus" [happy_var_2]+	)}++happyReduce_49 = happySpecReduce_2  4# happyReduction_49+happyReduction_49 happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_2 of { happy_var_2 -> +	happyIn8+		 (call "not" [happy_var_2]+	)}++happyReduce_50 = happySpecReduce_1  4# happyReduction_50+happyReduction_50 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TString happy_var_1) -> +	happyIn8+		 (Astring happy_var_1+	)}++happyReduce_51 = happySpecReduce_1  4# happyReduction_51+happyReduction_51 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> +	happyIn8+		 (Aint happy_var_1+	)}++happyReduce_52 = happySpecReduce_1  4# happyReduction_52+happyReduction_52 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> +	happyIn8+		 (Afloat happy_var_1+	)}++happyReduce_53 = happySpecReduce_1  5# happyReduction_53+happyReduction_53 happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	happyIn9+		 ([happy_var_1]+	)}++happyReduce_54 = happySpecReduce_3  5# happyReduction_54+happyReduction_54 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut9 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn9+		 (happy_var_1++[happy_var_3]+	)}}++happyReduce_55 = happySpecReduce_2  6# happyReduction_55+happyReduction_55 happy_x_2+	happy_x_1+	 =  case happyOut11 happy_x_2 of { happy_var_2 -> +	happyIn10+		 (happy_var_2+	)}++happyReduce_56 = happySpecReduce_2  6# happyReduction_56+happyReduction_56 happy_x_2+	happy_x_1+	 =  case happyOut12 happy_x_2 of { happy_var_2 -> +	happyIn10+		 (happy_var_2+	)}++happyReduce_57 = happySpecReduce_3  6# happyReduction_57+happyReduction_57 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut10 happy_x_1 of { happy_var_1 -> +	case happyOut11 happy_x_3 of { happy_var_3 -> +	happyIn10+		 (happy_var_1 . happy_var_3+	)}}++happyReduce_58 = happySpecReduce_3  6# happyReduction_58+happyReduction_58 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut10 happy_x_1 of { happy_var_1 -> +	case happyOut12 happy_x_3 of { happy_var_3 -> +	happyIn10+		 (happy_var_1 . happy_var_3+	)}}++happyReduce_59 = happySpecReduce_3  7# happyReduction_59+happyReduction_59 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn11+		 (\x -> Ast "for" [happy_var_1,Avar "$",happy_var_3,x]+	)}}++happyReduce_60 = happyReduce 5# 7# happyReduction_60+happyReduction_60 (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_1 of { happy_var_1 -> +	case happyOut7 happy_x_3 of { happy_var_3 -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn11+		 (\x -> Ast "for" [happy_var_1,happy_var_3,happy_var_5,x]+	) `HappyStk` happyRest}}}++happyReduce_61 = happyReduce 5# 7# happyReduction_61+happyReduction_61 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut11 happy_x_1 of { happy_var_1 -> +	case happyOut7 happy_x_3 of { happy_var_3 -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn11+		 (\x -> happy_var_1(Ast "for" [happy_var_3,Avar "$",happy_var_5,x])+	) `HappyStk` happyRest}}}++happyReduce_62 = happyReduce 7# 7# happyReduction_62+happyReduction_62 (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 happyOut11 happy_x_1 of { happy_var_1 -> +	case happyOut7 happy_x_3 of { happy_var_3 -> +	case happyOut7 happy_x_5 of { happy_var_5 -> +	case happyOut8 happy_x_7 of { happy_var_7 -> +	happyIn11+		 (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_5,happy_var_7,x])+	) `HappyStk` happyRest}}}}++happyReduce_63 = happySpecReduce_3  8# happyReduction_63+happyReduction_63 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn12+		 (\x -> Ast "let" [happy_var_1,happy_var_3,x]+	)}}++happyReduce_64 = happyReduce 5# 8# 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 happyOut12 happy_x_1 of { happy_var_1 -> +	case happyOut7 happy_x_3 of { happy_var_3 -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn12+		 (\x -> happy_var_1(Ast "let" [happy_var_3,happy_var_5,x])+	) `HappyStk` happyRest}}}++happyReduce_65 = happySpecReduce_2  9# happyReduction_65+happyReduction_65 happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_2 of { happy_var_2 -> +	happyIn13+		 (\x -> Ast "predicate" [happy_var_2,x]+	)}++happyReduce_66 = happySpecReduce_0  9# happyReduction_66+happyReduction_66  =  happyIn13+		 (id+	)++happyReduce_67 = happySpecReduce_3  10# happyReduction_67+happyReduction_67 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_3 of { happy_var_3 -> +	happyIn14+		 ((\x -> Ast "sortTuple" (x:(fst happy_var_3)),+                                                           \x -> Ast "sort" (x:(snd happy_var_3)))+	)}++happyReduce_68 = happySpecReduce_0  10# happyReduction_68+happyReduction_68  =  happyIn14+		 ((id,id)+	)++happyReduce_69 = happySpecReduce_2  11# happyReduction_69+happyReduction_69 happy_x_2+	happy_x_1+	 =  case happyOut8 happy_x_1 of { happy_var_1 -> +	case happyOut16 happy_x_2 of { happy_var_2 -> +	happyIn15+		 (([happy_var_1],[happy_var_2])+	)}}++happyReduce_70 = happyReduce 4# 11# happyReduction_70+happyReduction_70 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	case happyOut16 happy_x_4 of { happy_var_4 -> +	happyIn15+		 (((fst happy_var_1)++[happy_var_3],(snd happy_var_1)++[happy_var_4])+	) `HappyStk` happyRest}}}++happyReduce_71 = happySpecReduce_1  12# happyReduction_71+happyReduction_71 happy_x_1+	 =  happyIn16+		 (Avar "ascending"+	)++happyReduce_72 = happySpecReduce_1  12# happyReduction_72+happyReduction_72 happy_x_1+	 =  happyIn16+		 (Avar "descending"+	)++happyReduce_73 = happySpecReduce_0  12# happyReduction_73+happyReduction_73  =  happyIn16+		 (Avar "ascending"+	)++happyReduce_74 = happyReduce 4# 13# happyReduction_74+happyReduction_74 (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) -> +	happyIn17+		 (call "element" [Avar happy_var_3]+	) `HappyStk` happyRest}++happyReduce_75 = happyReduce 4# 13# happyReduction_75+happyReduction_75 (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) -> +	happyIn17+		 (call "attribute" [Avar happy_var_3]+	) `HappyStk` happyRest}++happyReduce_76 = happyReduce 6# 14# happyReduction_76+happyReduction_76 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut19 happy_x_1 of { happy_var_1 -> +	case happyOut20 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_5 of { (QName happy_var_5) -> +	happyIn18+		 (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: "++(show (head happy_var_1))++" '"++happy_var_5++"'")+	) `HappyStk` happyRest}}}++happyReduce_77 = happyReduce 5# 14# 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 happyOut19 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_4 of { (QName happy_var_4) -> +	happyIn18+		 (if head happy_var_1 == Astring happy_var_4+							     then Ast "construction" (happy_var_1++[call "empty" []])+                                                          else error("Unmatched tags in element construction: "++(show (head happy_var_1))++" '"++happy_var_4++"'")+	) `HappyStk` happyRest}}++happyReduce_78 = happySpecReduce_2  14# happyReduction_78+happyReduction_78 happy_x_2+	happy_x_1+	 =  case happyOut19 happy_x_1 of { happy_var_1 -> +	happyIn18+		 (Ast "construction" (happy_var_1++[call "empty" []])+	)}++happyReduce_79 = happyReduce 7# 14# happyReduction_79+happyReduction_79 (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 happyOut8 happy_x_3 of { happy_var_3 -> +	case happyOut9 happy_x_6 of { happy_var_6 -> +	happyIn18+		 (Ast "element_construction" [happy_var_3,concatenateAll happy_var_6]+	) `HappyStk` happyRest}}++happyReduce_80 = happyReduce 7# 14# happyReduction_80+happyReduction_80 (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 happyOut8 happy_x_3 of { happy_var_3 -> +	case happyOut9 happy_x_6 of { happy_var_6 -> +	happyIn18+		 (Ast "attribute_construction" [happy_var_3,concatenateAll happy_var_6]+	) `HappyStk` happyRest}}++happyReduce_81 = happyReduce 5# 14# happyReduction_81+happyReduction_81 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (QName happy_var_2) -> +	case happyOut9 happy_x_4 of { happy_var_4 -> +	happyIn18+		 (Ast "element_construction" [Astring happy_var_2,concatenateAll happy_var_4]+	) `HappyStk` happyRest}}++happyReduce_82 = happyReduce 5# 14# happyReduction_82+happyReduction_82 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (QName happy_var_2) -> +	case happyOut9 happy_x_4 of { happy_var_4 -> +	happyIn18+		 (Ast "attribute_construction" [Astring happy_var_2,concatenateAll happy_var_4]+	) `HappyStk` happyRest}}++happyReduce_83 = happySpecReduce_2  15# happyReduction_83+happyReduction_83 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_2 of { (QName happy_var_2) -> +	happyIn19+		 ([Astring happy_var_2,Ast "attributes" []]+	)}++happyReduce_84 = happySpecReduce_3  15# happyReduction_84+happyReduction_84 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_2 of { (QName happy_var_2) -> +	case happyOut21 happy_x_3 of { happy_var_3 -> +	happyIn19+		 ([Astring happy_var_2,Ast "attributes" happy_var_3]+	)}}++happyReduce_85 = happySpecReduce_3  16# happyReduction_85+happyReduction_85 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut9 happy_x_2 of { happy_var_2 -> +	happyIn20+		 ([concatenateAll happy_var_2]+	)}++happyReduce_86 = happySpecReduce_1  16# happyReduction_86+happyReduction_86 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TString happy_var_1) -> +	happyIn20+		 ([Astring happy_var_1]+	)}++happyReduce_87 = happySpecReduce_1  16# happyReduction_87+happyReduction_87 happy_x_1+	 =  case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> +	happyIn20+		 ([Astring happy_var_1]+	)}++happyReduce_88 = happySpecReduce_1  16# happyReduction_88+happyReduction_88 happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	happyIn20+		 ([happy_var_1]+	)}++happyReduce_89 = happyReduce 4# 16# happyReduction_89+happyReduction_89 (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 happyOut9 happy_x_3 of { happy_var_3 -> +	happyIn20+		 (happy_var_1++[concatenateAll happy_var_3]+	) `HappyStk` happyRest}}++happyReduce_90 = happySpecReduce_2  16# happyReduction_90+happyReduction_90 happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (TString happy_var_2) -> +	happyIn20+		 (happy_var_1++[Astring happy_var_2]+	)}}++happyReduce_91 = happySpecReduce_2  16# happyReduction_91+happyReduction_91 happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (XMLtext happy_var_2) -> +	happyIn20+		 (happy_var_1++[Astring happy_var_2]+	)}}++happyReduce_92 = happySpecReduce_2  16# happyReduction_92+happyReduction_92 happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> +	case happyOut18 happy_x_2 of { happy_var_2 -> +	happyIn20+		 (happy_var_1++[happy_var_2]+	)}}++happyReduce_93 = happySpecReduce_3  17# happyReduction_93+happyReduction_93 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) -> +	happyIn21+		 ([Ast "pair" [Astring happy_var_1,Astring happy_var_3]]+	)}}++happyReduce_94 = happyReduce 5# 17# happyReduction_94+happyReduction_94 (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 happyOut8 happy_x_4 of { happy_var_4 -> +	happyIn21+		 ([Ast "pair" [Astring happy_var_1,happy_var_4]]+	) `HappyStk` happyRest}}++happyReduce_95 = happyReduce 4# 17# happyReduction_95+happyReduction_95 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut21 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) -> +	happyIn21+		 (happy_var_1++[Ast "pair" [Astring happy_var_2,Astring happy_var_4]]+	) `HappyStk` happyRest}}}++happyReduce_96 = happyReduce 6# 17# happyReduction_96+happyReduction_96 (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 happyOut21 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (QName happy_var_2) -> +	case happyOut8 happy_x_5 of { happy_var_5 -> +	happyIn21+		 (happy_var_1++[Ast "pair" [Astring happy_var_2,happy_var_5]]+	) `HappyStk` happyRest}}}++happyReduce_97 = happySpecReduce_1  18# happyReduction_97+happyReduction_97 happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	happyIn22+		 (Ast "step" (happy_var_1 "child_step" (Avar "."))+	)}++happyReduce_98 = happySpecReduce_2  18# happyReduction_98+happyReduction_98 happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_2 of { happy_var_2 -> +	happyIn22+		 (Ast "step" (happy_var_2 "attribute_step" (Avar "."))+	)}++happyReduce_99 = happySpecReduce_2  18# happyReduction_99+happyReduction_99 happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut23 happy_x_2 of { happy_var_2 -> +	happyIn22+		 (Ast "step" [happy_var_2 (Ast "step" (happy_var_1 "child_step" (Avar ".")))]+	)}}++happyReduce_100 = happySpecReduce_3  18# happyReduction_100+happyReduction_100 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_2 of { happy_var_2 -> +	case happyOut23 happy_x_3 of { happy_var_3 -> +	happyIn22+		 (Ast "step" (map happy_var_3 (happy_var_2 "attribute_step" (Avar ".")))+	)}}++happyReduce_101 = happySpecReduce_1  19# happyReduction_101+happyReduction_101 happy_x_1+	 =  case happyOut24 happy_x_1 of { happy_var_1 -> +	happyIn23+		 (happy_var_1+	)}++happyReduce_102 = happySpecReduce_2  19# happyReduction_102+happyReduction_102 happy_x_2+	happy_x_1+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	happyIn23+		 (happy_var_2 . happy_var_1+	)}}++happyReduce_103 = happySpecReduce_2  20# happyReduction_103+happyReduction_103 happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_2 of { happy_var_2 -> +	happyIn24+		 (\e -> Ast "step" (happy_var_2 "child_step" e)+	)}++happyReduce_104 = happySpecReduce_3  20# happyReduction_104+happyReduction_104 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn24+		 (\e -> Ast "step" (happy_var_3 "attribute_step" e)+	)}++happyReduce_105 = happySpecReduce_3  20# happyReduction_105+happyReduction_105 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn24+		 (\e -> Ast "step" (happy_var_3 "descendant_step" e)+	)}++happyReduce_106 = happyReduce 4# 20# happyReduction_106+happyReduction_106 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_4 of { happy_var_4 -> +	happyIn24+		 (\e -> Ast "step" (happy_var_4 "attribute_descendant_step" e)+	) `HappyStk` happyRest}++happyReduce_107 = happySpecReduce_2  20# happyReduction_107+happyReduction_107 happy_x_2+	happy_x_1+	 =  happyIn24+		 (\e -> Ast "step" [Ast "parent_step" [e]]+	)++happyReduce_108 = happySpecReduce_1  21# happyReduction_108+happyReduction_108 happy_x_1+	 =  case happyOut26 happy_x_1 of { happy_var_1 -> +	happyIn25+		 (\t e -> [happy_var_1 t e]+	)}++happyReduce_109 = happyReduce 4# 21# happyReduction_109+happyReduction_109 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_3 of { happy_var_3 -> +	happyIn25+		 (\t e -> (happy_var_1 t e)++[happy_var_3]+	) `HappyStk` happyRest}}++happyReduce_110 = happySpecReduce_1  22# happyReduction_110+happyReduction_110 happy_x_1+	 =  case happyOut27 happy_x_1 of { happy_var_1 -> +	happyIn26+		 (\t e -> happy_var_1 t e+	)}++happyReduce_111 = happySpecReduce_1  22# happyReduction_111+happyReduction_111 happy_x_1+	 =  happyIn26+		 (\t e -> Ast t [Astring "*",e]+	)++happyReduce_112 = happySpecReduce_1  22# happyReduction_112+happyReduction_112 happy_x_1+	 =  case happyOutTok happy_x_1 of { (QName happy_var_1) -> +	happyIn26+		 (\t e -> Ast t [Astring happy_var_1,e]+	)}++happyReduce_113 = happySpecReduce_1  23# happyReduction_113+happyReduction_113 happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	happyIn27+		 (\_ _ -> happy_var_1+	)}++happyReduce_114 = happySpecReduce_1  23# happyReduction_114+happyReduction_114 happy_x_1+	 =  happyIn27+		 (\_ e -> e+	)++happyReduce_115 = happySpecReduce_3  23# happyReduction_115+happyReduction_115 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut9 happy_x_2 of { happy_var_2 -> +	happyIn27+		 (\t e -> if e == Avar "."+                                                                     then concatenateAll happy_var_2+	                                                          else Ast "context" [e,Astring t,concatenateAll happy_var_2]+	)}++happyReduce_116 = happySpecReduce_2  23# happyReduction_116+happyReduction_116 happy_x_2+	happy_x_1+	 =  happyIn27+		 (\_ _ -> call "empty" []+	)++happyReduce_117 = happyReduce 4# 23# happyReduction_117+happyReduction_117 (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 happyOut9 happy_x_3 of { happy_var_3 -> +	happyIn27+		 (\_ e -> if e == Avar "."+                                                                     then call happy_var_1 happy_var_3+                                                                  else Ast "context" [e,call happy_var_1 happy_var_3]+	) `HappyStk` happyRest}}++happyReduce_118 = happySpecReduce_3  23# happyReduction_118+happyReduction_118 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (QName happy_var_1) -> +	happyIn27+		 (if elem happy_var_1 ["text"]+                                                             then \_ e -> call happy_var_1 [e]+                                                          else \_ _ -> call happy_var_1 []+	)}++happyNewToken action sts stk [] =+	happyDoAction 73# notHappyAtAll action sts stk []++happyNewToken action sts stk (tk:tks) =+	let cont i = happyDoAction i tk action sts stk tks in+	case tk of {+	RETURN -> cont 1#;+	SOME -> cont 2#;+	EVERY -> cont 3#;+	IF -> cont 4#;+	THEN -> cont 5#;+	ELSE -> cont 6#;+	LB -> cont 7#;+	RB -> cont 8#;+	LP -> cont 9#;+	RP -> cont 10#;+	LSB -> cont 11#;+	RSB -> cont 12#;+	LESCAPE -> cont 13#;+	RESCAPE -> cont 14#;+	TO -> cont 15#;+	PLUS -> cont 16#;+	MINUS -> cont 17#;+	TIMES -> cont 18#;+	DIV -> cont 19#;+	IDIV -> cont 20#;+	MOD -> cont 21#;+	TEQ -> cont 22#;+	TNE -> cont 23#;+	TLT -> cont 24#;+	TLE -> cont 25#;+	TGT -> cont 26#;+	TGE -> cont 27#;+	PRE -> cont 28#;+	POST -> cont 29#;+	IS -> cont 30#;+	SEQ -> cont 31#;+	SNE -> cont 32#;+	SLT -> cont 33#;+	SLE -> cont 34#;+	SGT -> cont 35#;+	SGE -> cont 36#;+	AND -> cont 37#;+	OR -> cont 38#;+	NOT -> cont 39#;+	UNION -> cont 40#;+	INTERSECT -> cont 41#;+	EXCEPT -> cont 42#;+	FOR -> cont 43#;+	LET -> cont 44#;+	IN -> cont 45#;+	COMMA -> cont 46#;+	ASSIGN -> cont 47#;+	WHERE -> cont 48#;+	ORDER -> cont 49#;+	BY -> cont 50#;+	ASCENDING -> cont 51#;+	DESCENDING -> cont 52#;+	ELEMENT -> cont 53#;+	ATTRIBUTE -> cont 54#;+	STAG -> cont 55#;+	ETAG -> cont 56#;+	SATISFIES -> cont 57#;+	ATSIGN -> cont 58#;+	SLASH -> cont 59#;+	QName happy_dollar_dollar -> cont 60#;+	DECLARE -> cont 61#;+	FUNCTION -> cont 62#;+	VARIABLE -> cont 63#;+	AT -> cont 64#;+	DOTS -> cont 65#;+	DOT -> cont 66#;+	SEMI -> cont 67#;+	Variable happy_dollar_dollar -> cont 68#;+	XMLtext happy_dollar_dollar -> cont 69#;+	TInteger happy_dollar_dollar -> cont 70#;+	TFloat happy_dollar_dollar -> cont 71#;+	TString happy_dollar_dollar -> cont 72#;+	_ -> 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 0# tks) (\x -> happyReturn (happyOut4 x))++happySeq = happyDontSeq+++-- Abstract Syntax Tree for XQueries+data Ast = Ast String [Ast]+         | Avar String+         | Aint Int+         | Afloat Float+         | Astring String+         deriving Eq+++instance Show Ast+  where show (Ast s []) = s ++ "()"+        show (Ast s (x:xs)) = s ++ "(" ++ (show x)+                              ++ (foldr (\a r -> ","++(show a)++r) "" xs)+                              ++ ")"+        show (Avar s) = s+        show (Aint n) = show n+        show (Afloat n) = show n+        show (Astring s) = "\'" ++ s ++ "\'"+++call :: String -> [Ast] -> Ast+call name args = Ast "call" ((Avar name):args)+++concatenateAll :: [Ast] -> Ast+concatenateAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs+concatenateAll _ = call "empty" []+++concatAll :: [Ast] -> Ast+concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs+concatAll _ = call "empty" []+++data Token+  = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB+  | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD+  | TEQ | TNE | TLT | TLE | TGT | TGE | SEQ | SNE | SLT | SLE | SGT | SGE+  | AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA+  | ASSIGN | WHERE | ORDER | BY | ASCENDING | DESCENDING | ELEMENT+  | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN | SLASH | DECLARE | SEMI+  | FUNCTION | VARIABLE |AT | DOT | DOTS | TokenEOF | PRE | POST | IS+  | QName String | Variable String | XMLtext String | TInteger Int+  | TFloat Float | TString String | TError String+    deriving Eq+++instance Show Token+    where show (QName s) = "QName("++s++")"+	  show (Variable s) = "Variable("++s++")"+	  show (XMLtext s) = "XMLtext("++s++")"+	  show (TInteger n) = "Integer("++(show n)++")"+	  show (TFloat n) = "Double("++(show n)++")"+	  show (TString s) = "String("++s++")"+          show t = case filter (\(n,_) -> n==t) tokenList of+                     (_,b):_ -> b+                     _ -> "Illegal token"+++tokenList :: [(Token,String)]+tokenList = [(RETURN,"return"),(SOME,"some"),(EVERY,"every"),(IF,"if"),(THEN,"then"),(ELSE,"else"),+             (LB,"["),(RB,"]"),(LP,"("),(RP,")"),(LSB,"{"),(RSB,"}"),(LESCAPE,"\"{"),(RESCAPE,"}\""),+             (TO,"to"),(PLUS,"+"),(MINUS,"-"),(TIMES,"*"),(DIV,"div"),(IDIV,"idiv"),(MOD,"mod"),+             (TEQ,"="),(TNE,"!="),(TLT,"<"),(TLE,"<="),(TGT,">"),(TGE,">="),(PRE,"<<"),(POST,">>"),+             (IS,"is"),(SEQ,"eq"),(SNE,"ne"),(SLT,"lt"),(SLE,"le"),(SGT,"gt"),(SGE,"ge"),(AND,"and"),+             (OR,"or"),(NOT,"not"),(UNION,"union"),(INTERSECT,"intersect"),(EXCEPT,"except"),+             (FOR,"for"),(LET,"let"),(IN,"in"),(COMMA,"','"),(ASSIGN,":="),(WHERE,"where"),(ORDER,"order"),+             (BY,"by"),(ASCENDING,"ascending"),(DESCENDING,"descending"),(ELEMENT,"element"),+             (ATTRIBUTE,"attribute"),(STAG,"</"),(ETAG,"/>"),(SATISFIES,"satisfies"),(ATSIGN,"@"),+             (SLASH,"/"),(DECLARE,"declare"),(FUNCTION,"function"),(VARIABLE,"variable"),+             (AT,"at"),(DOTS,".."),(DOT,"."),(SEMI,";")]+++parseError [] = error "Reached end-of-input"+parseError [_] = error "Reached end-of-input"+parseError tk = error("Parse error: "++(show (take 10 (init tk))))+++scan :: String -> [Token]+scan cs = lexer cs [0]++xmlText :: String -> [Token]+xmlText "" = []+xmlText text = [XMLtext text]++-- scans XML syntax and returns an XMLtext token with the text+xml :: String -> String -> [Int] -> [Token]+xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n))+xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n)+xml ('<':'!':'-':cs) text n = xmlComment cs (text++"<!-") n+xml ('<':cs) text (k:n) = (xmlText text)++(TLT : lexer cs (k+2:n))+xml ('\'':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)+xml ('\"':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)+xml ('(':':':cs) text n = xqComment cs text n+xml (c:cs) text n = xml cs (text++[c]) n+xml [] text _ = xmlText text++xqComment :: String -> String -> [Int] -> [Token]+xqComment (':':')':cs) text n = xml cs text n+xqComment (_:cs) text n = xqComment cs text n+xqComment [] text _ = xmlText text++xmlComment :: String -> String -> [Int] -> [Token]+xmlComment ('-':'>':cs) text n = xml cs (text++"->") n+xmlComment (c:cs) text n = xmlComment cs (text++[c]) n+xmlComment [] text _ = xmlText text++isQN :: Char -> Bool+isQN c = elem c "_:-" || isDigit c || isAlpha c++isVar :: Char -> Bool+isVar c = elem c "_" || isDigit c || isAlpha c++-- the XQuery scanner+lexer :: String -> [Int] -> [Token]+lexer [] [0] = []+lexer [] _ = error "Unbalanced tags"+lexer (' ':'>':' ':cs) n = TGT : lexer cs n+lexer (c:cs) n+      | isSpace c = lexer cs n+      | isAlpha c = lexVar (c:cs) n+      | isDigit c = lexNum (c:cs) n+lexer ('$':c:cs) n | isAlpha c+      = let (var,rest) = span isVar (c:cs)+        in (Variable var) : lexer rest n+lexer ('\'':'{':cs) n = LESCAPE : lexer cs n+lexer ('\"':'{':cs) n = LESCAPE : lexer cs n+lexer (':':'=':cs) n = ASSIGN : lexer cs n+lexer ('<':'/':cs) n = STAG : lexer cs n+lexer ('<':'=':cs) n = TLE : lexer cs n+lexer ('>':'=':cs) n = TGE : lexer cs n+lexer ('<':'<':cs) n = PRE : lexer cs n+lexer ('>':'>':cs) n = POST : lexer cs n+lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)+lexer ('(':':':cs) n = lexComment cs n+lexer ('<':'!':'-':cs) n = lexXmlComment cs "<!-" n+lexer ('.':'.':cs) n = DOTS : lexer cs n+lexer ('.':cs) n = DOT : lexer cs n+lexer ('}':'\'':cs) n = RESCAPE : lexer cs n+lexer ('}':'\"':cs) n = RESCAPE : lexer cs n+lexer ('!':'=':cs) n = TNE : lexer cs n+lexer ('\'':cs) n = lexString cs n+lexer ('\"':cs) n = lexString2 cs n+lexer ('[':cs) n = LB : lexer cs n+lexer (']':cs) n = RB : lexer cs n+lexer ('(':cs) n = LP : lexer cs n+lexer (')':cs) n = RP : lexer cs n+lexer ('}':cs) [_,n] = RSB : lexer cs [n]+lexer ('}':cs) (_:n:ns) = RSB : (if n==0 then lexer cs (n:ns) else xml cs "" (n:ns))+lexer ('+':cs) n = PLUS : lexer cs n+lexer ('-':cs) n = MINUS : lexer cs n+lexer ('*':cs) n = TIMES : lexer cs n+lexer ('=':cs) n = TEQ : lexer cs n+lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n+lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n)+lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (0:n) else xml cs "" (k-1:n))+lexer (',':cs) n = COMMA : lexer cs n+lexer ('@':cs) n = ATSIGN : lexer cs n+lexer ('/':cs) n = SLASH : lexer cs n+lexer ('{':cs) n = LSB : lexer cs (0:n)+lexer ('|':cs) n = UNION : lexer cs n+lexer (';':cs) n = SEMI : lexer cs n+lexer (c:cs) n = error("Illegal character "++[c])++lexNum :: String -> [Int] -> [Token]+lexNum cs n = if null rest || head rest /= '.'+                 then TInteger (read k) : lexer rest n+              else let (m,rest2) = span isDigit (tail rest)+                       val::Float = read (k++('.':m))+                   in case rest2 of+                        ('e':rest3) -> let (exp,rest4) = span isDigit rest3+                                       in (TFloat (val*10^(read exp))) : lexer rest4 n+                        _ -> (TFloat val) : lexer rest2 n+      where (k,rest) = span isDigit cs++lexString :: String -> [Int] -> [Token]+lexString cs n = TString s : lexer (tail rest) n+    where (s,rest) = span inString cs+          inString c = c /= '\''++lexString2 :: String -> [Int] -> [Token]+lexString2 cs n = TString s : lexer (tail rest) n+    where (s,rest) = span inString cs+          inString c = c /= '\"'++lexComment :: String -> [Int] -> [Token]+lexComment (':':')':cs) n = lexer cs n+lexComment (_:cs) n = lexComment cs n+lexComment [] n = []++lexXmlComment :: String -> String -> [Int] -> [Token]+lexXmlComment ('-':'>':cs) text n = (xmlText (text++"->"))++(lexer cs n)+lexXmlComment (c:cs) text n = lexXmlComment cs (text++[c]) n+lexXmlComment [] text _ = xmlText text++lexVar :: String -> [Int] -> [Token]+lexVar cs n =+   case span isQN cs of+      ("return",rest) -> RETURN : lexer rest n+      ("some",rest) -> SOME : lexer rest n+      ("every",rest) -> EVERY : lexer rest n+      ("if",rest) -> IF : lexer rest n+      ("then",rest) -> THEN : lexer rest n+      ("else",rest) -> ELSE : lexer rest n+      ("to",rest) -> TO : lexer rest n+      ("div",rest) -> DIV : lexer rest n+      ("idiv",rest) -> IDIV : lexer rest n+      ("mod",rest) -> MOD : lexer rest n+      ("and",rest) -> AND : lexer rest n+      ("or",rest) -> OR : lexer rest n+      ("not",rest) -> NOT : lexer rest n+      ("union",rest) -> UNION : lexer rest n+      ("intersect",rest) -> INTERSECT : lexer rest n+      ("except",rest) -> EXCEPT : lexer rest n+      ("for",rest) -> FOR : lexer rest n+      ("let",rest) -> LET : lexer rest n+      ("in",rest) -> IN : lexer rest n+      ("where",rest) -> WHERE : lexer rest n+      ("order",rest) -> ORDER : lexer rest n+      ("by",rest) -> BY : lexer rest n+      ("ascending",rest) -> ASCENDING : lexer rest n+      ("descending",rest) -> DESCENDING : lexer rest n+      ("element",rest) -> ELEMENT : lexer rest n+      ("attribute",rest) -> ATTRIBUTE : lexer rest n+      ("satisfies",rest) -> SATISFIES : lexer rest n+      ("declare",rest) -> DECLARE : lexer rest n+      ("function",rest) -> FUNCTION : lexer rest n+      ("variable",rest) -> VARIABLE : lexer rest n+      ("at",rest) -> AT : lexer rest n+      ("eq",rest) -> SEQ : lexer rest n+      ("ne",rest) -> SNE : lexer rest n+      ("lt",rest) -> SLT : lexer rest n+      ("le",rest) -> SLE : lexer rest n+      ("gt",rest) -> SGT : lexer rest n+      ("ge",rest) -> SGE : lexer rest n+      ("is",rest) -> IS : lexer rest n+      (var,rest) -> QName var : lexer rest n+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp ++{-# LINE 28 "templates/GenericTemplate.hs" #-}+++data Happy_IntList = HappyCons Int# Happy_IntList++++++{-# 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 0#, it means we've just accepted a partial+-- parse (a %partial parser).  We must ignore the saved token on the top of+-- the stack in this case.+happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =+	happyReturn1 ans+happyAccept j tk st sts (HappyStk ans _) = +	(happyTcHack j (happyTcHack st)) (happyReturn1 ans)++-----------------------------------------------------------------------------+-- Arrays only: do the next action++++happyDoAction i tk st+	= {- nothing -}+++	  case action of+		0#		  -> {- nothing -}+				     happyFail i tk st+		-1# 	  -> {- nothing -}+				     happyAccept i tk st+		n | (n <# (0# :: Int#)) -> {- nothing -}++				     (happyReduceArr ! rule) i tk st+				     where rule = (I# ((negateInt# ((n +# (1# :: Int#))))))+		n		  -> {- nothing -}+++				     happyShift new_state i tk st+				     where new_state = (n -# (1# :: Int#))+   where off    = indexShortOffAddr happyActOffsets st+	 off_i  = (off +# i)+	 check  = if (off_i >=# (0# :: Int#))+			then (indexShortOffAddr happyCheck off_i ==#  i)+			else False+ 	 action | check     = indexShortOffAddr happyTable off_i+		| otherwise = indexShortOffAddr happyDefActions st++{-# LINE 127 "templates/GenericTemplate.hs" #-}+++indexShortOffAddr (HappyA# arr) off =+#if __GLASGOW_HASKELL__ > 500+	narrow16Int# i+#elif __GLASGOW_HASKELL__ == 500+	intToInt16# i+#else+	(i `iShiftL#` 16#) `iShiftRA#` 16#+#endif+  where+#if __GLASGOW_HASKELL__ >= 503+	i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)+#else+	i = word2Int# ((high `shiftL#` 8#) `or#` low)+#endif+	high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+	low  = int2Word# (ord# (indexCharOffAddr# arr off'))+	off' = off *# 2#++++++data HappyAddr = HappyA# Addr#+++++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++{-# LINE 170 "templates/GenericTemplate.hs" #-}++-----------------------------------------------------------------------------+-- Shifting a token++happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =+     let i = (case unsafeCoerce# x of { (I# (i)) -> i }) in+--     trace "shifting the error token" $+     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)++happyShift new_state i tk st sts stk =+     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)++-- happyReduce is specialised for the common cases.++happySpecReduce_0 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_0 nt fn j tk st@((action)) sts stk+     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)++happySpecReduce_1 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')+     = let r = fn v1 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_2 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')+     = let r = fn v1 v2 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_3 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')+     = let r = fn v1 v2 v3 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happyReduce k i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyReduce k nt fn j tk st sts stk+     = case happyDrop (k -# (1# :: Int#)) sts of+	 sts1@((HappyCons (st1@(action)) (_))) ->+        	let r = fn stk in  -- it doesn't hurt to always seq here...+       		happyDoSeq r (happyGoto nt j tk st1 sts1 r)++happyMonadReduce k nt fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyMonadReduce k nt fn j tk st sts stk =+        happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))+       where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts))+             drop_stk = happyDropStk k stk++happyMonad2Reduce k nt fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyMonad2Reduce k nt fn j tk st sts stk =+       happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))+       where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts))+             drop_stk = happyDropStk k stk++             off    = indexShortOffAddr happyGotoOffsets st1+             off_i  = (off +# nt)+             new_state = indexShortOffAddr happyTable off_i+++++happyDrop 0# l = l+happyDrop n (HappyCons (_) (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+++happyGoto nt j tk st = +   {- nothing -}+   happyDoAction j tk new_state+   where off    = indexShortOffAddr happyGotoOffsets st+	 off_i  = (off +# nt)+ 	 new_state = indexShortOffAddr happyTable off_i+++++-----------------------------------------------------------------------------+-- Error recovery (0# is the error token)++-- parse error if we are in recovery and we fail again+happyFail  0# tk old_st _ stk =+--	trace "failing" $ +    	happyError_ tk++{-  We don't need state discarding for our restricted implementation of+    "error".  In fact, it can cause some bogus parses, so I've disabled it+    for now --SDM++-- discard a state+happyFail  0# tk old_st (HappyCons ((action)) (sts)) +						(saved_tok `HappyStk` _ `HappyStk` stk) =+--	trace ("discarding state, depth " ++ show (length stk))  $+	happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))+-}++-- Enter error recovery: generate an error token,+--                       save the old token and carry on.+happyFail  i tk (action) sts stk =+--      trace "entering error recovery" $+	happyDoAction 0# tk action sts ( (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.+++{-# NOINLINE happyDoAction #-}+{-# NOINLINE happyTable #-}+{-# NOINLINE happyCheck #-}+{-# NOINLINE happyActOffsets #-}+{-# NOINLINE happyGotoOffsets #-}+{-# NOINLINE happyDefActions #-}++{-# NOINLINE happyShift #-}+{-# NOINLINE happySpecReduce_0 #-}+{-# NOINLINE happySpecReduce_1 #-}+{-# NOINLINE happySpecReduce_2 #-}+{-# NOINLINE happySpecReduce_3 #-}+{-# NOINLINE happyReduce #-}+{-# NOINLINE happyMonadReduce #-}+{-# NOINLINE happyGoto #-}+{-# NOINLINE happyFail #-}++-- end of Happy Template.

@@ -0,0 +1,33 @@+{-------------------------------------------------------------------------------------+-+- The XQuery Compiler and Interpreter+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 03/22/08, last update: 05/06/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}++-- | HXQ is a fast and space-efficient compiler from XQuery (the standard+-- query language for XML) to embedded Haskell code. The translation is+-- based on Haskell templates. It also provides an interpreter for+-- evaluating ad-hoc XQueries read from input or from files.+-- For more information, look at <http://lambda.uta.edu/HXQ/>.+module XML.HXQ.XQuery (+       -- * The XML Data Representation+       XTree(..), XSeq, Tag, AttList, putXSeq,+       -- * The XQuery Compiler+       xq, xe,+       -- * The XQuery Interpreter+       xquery, xfile+    ) where++import HXML(AttList)+import XML.HXQ.XTree+import XML.HXQ.Compiler+import XML.HXQ.Interpreter

@@ -0,0 +1,38 @@+{-------------------------------------------------------------------------------------+-+- The XQuery Compiler and Interpreter with HDBC connectivity+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 05/12/08, last update: 05/12/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++-- | HXQ is a fast and space-efficient compiler from XQuery (the standard+-- query language for XML) to embedded Haskell code. The translation is+-- based on Haskell templates. It also provides an interpreter for+-- evaluating ad-hoc XQueries read from input or from files.+-- For more information, look at <http://lambda.uta.edu/HXQ/>.+module XML.HXQ.XQueryDB (+       -- * The XML Data Representation+       XTree(..), XSeq, Tag, AttList, putXSeq,+       -- * The XQuery Compiler+       xq, xe,+       -- * The XQuery Interpreter+       xquery, xfile,+       -- * The XQuery Compiler with Database Connectivity+       xqdb, disconnect, prepareSQL, executeSQL+    ) where++import HXML(AttList)+import XML.HXQ.XTree+import XML.HXQ.Compiler+import XML.HXQ.Interpreter+import XML.HXQ.DB+import Database.HDBC(disconnect)

@@ -0,0 +1,101 @@+{-------------------------------------------------------------------------------------+-+- XML Trees (rose trees)+- Programmer: Leonidas Fegaras+- Email: fegaras@cse.uta.edu+- Web: http://lambda.uta.edu/+- Creation: 05/01/08, last update: 05/05/08+- +- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.+- This material is provided as is, with absolutely no warranty expressed or implied.+- Any use is at your own risk. Permission is hereby granted to use or copy this program+- for any purpose, provided the above notices are retained on all copies.+-+--------------------------------------------------------------------------------------}+++{-# OPTIONS_GHC -funbox-strict-fields #-}+++module XML.HXQ.XTree where++import System.IO+import XMLParse(XMLEvent(..))+import HXML(AttList)+++type Tag = String+++-- | Rose tree representation of XML data.+-- The Int in XElem is the preorder numbering used for the document order of nodes.+data XTree =  XElem    !Tag !AttList !Int [XTree]   -- ^ an XML tree node (element)+           |  XText    !String          -- ^ an XML tree leaf (PCDATA)+           |  XInt     !Int             -- ^ an XML tree leaf (int)+           |  XFloat   !Float           -- ^ an XML tree leaf (float)+           |  XBool    !Bool            -- ^ an XML tree leaf (boolean)+           |  XPI      Tag String	-- ^ processing instruction+           |  XGERef   Tag		-- ^ general entity reference+           |  XComment String		-- ^ comment+           |  XError   String		-- ^ error report+           deriving Eq++type XSeq = [XTree]+++showAL :: AttList -> String+showAL = foldr(\(a,v) r -> " "++a++"=\""++v++"\""++r) []++showXT :: XTree -> Bool -> String+showXT e pad+    = case e of+        XElem tag al _ [] -> "<"++tag++(showAL al)++"/>"+        XElem tag al _ xs -> "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">"+        XText text -> text+        XInt n -> p++(show n)+        XFloat n -> p++(show n)+        XBool v -> p++(if v then "true" else "false")+        XComment s -> "<!--"++s++"-->"+        XPI n s -> "<?"++n++" "++s++">"+        XError s -> error s+        _ -> ""+      where p = if pad then " " else ""++showXS :: XSeq -> String+showXS [] = ""+showXS (x:xs) = (showXT x False) ++ (concatMap (\x -> showXT x True) xs)++instance Show XTree where+    show t = showXT t False+++-- | Print the XQuery result (which is a sequence of XML fragments) with no waiting+putXSeq :: XSeq -> IO ()+putXSeq xs = hSetBuffering stdout NoBuffering >> putStrLn (showXS xs)+++{--------------- Build the rose tree from the XML stream ----------------------------}+++type Stream = [XMLEvent]+++-- lazily materialize the SAX stream into a DOM tree+materialize :: Stream -> XTree+materialize stream = XElem "document" [] 1 [head (filter (\x -> case x of XElem _ _ _ _ -> True; _ -> False)+                                                         ((\(x,_,_)->x) (ml stream 2)))]+        where m ((TextEvent t):xs) i = (XText t,xs,i)+              m ((EmptyEvent n atts):xs) i = (XElem n atts i [],xs,i+1)+              m ((StartEvent n atts):xs) i = let (el,xs',i') = ml xs (i+1)+                                             in (XElem n atts i el,xs',i')+              m ((PIEvent n s):xs) i = (XPI n s,xs,i)+              m ((CommentEvent s):xs) i = (XComment s,xs,i)+              m ((GERefEvent n):xs) i = (XGERef n,xs,i)+              m ((ErrorEvent s):xs) i = (XError s,xs,i)+              m (_:xs) i = (XError "unrecognized XML event",xs,i)+              m [] i = (XError "unbalanced tags",[],i)+              ml [] i = ([],[],i)+              ml ((EndEvent n):xs) i = ([],xs,i)+              ml xs i = let (e,xs',i') = m xs i+                            (el,xs'',i'') = ml xs' i'+                        in (e:el,xs'',i'')

@@ -1,25 +0,0 @@-{----------------------------------------------------------------------------------------- The XQuery Compiler and Interpreter-- Programmer: Leonidas Fegaras-- Email: fegaras@cse.uta.edu-- Web: http://lambda.uta.edu/-- Creation: 03/22/08, last update: 05/01/08-- -- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.-- This material is provided as is, with absolutely no warranty expressed or implied.-- Any use is at your own risk. Permission is hereby granted to use or copy this program-- for any purpose, provided the above notices are retained on all copies.-----------------------------------------------------------------------------------------}---{-# OPTIONS_GHC -fth #-}--module XQuery (-       XTree(..), XSeq, xq, xe, cq, xquery, xfile, putXSeq-    ) where--import XTree-import XQueryCompiler-import XQueryInterpreter

@@ -1,563 +0,0 @@-{----------------------------------------------------------------------------------------- A Compiler from XQuery to Haskell-- Programmer: Leonidas Fegaras-- Email: fegaras@cse.uta.edu-- Web: http://lambda.uta.edu/-- Creation: 02/15/08, last update: 05/02/08-- -- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.-- This material is provided as is, with absolutely no warranty expressed or implied.-- Any use is at your own risk. Permission is hereby granted to use or copy this program-- for any purpose, provided the above notices are retained on all copies.-----------------------------------------------------------------------------------------}---{-# OPTIONS_GHC -fth #-}--module XQueryCompiler where--import Char(isDigit)-import List(sortBy)-import Language.Haskell.TH-import XMLParse(parseDocument)-import HXML(AttList)-import XQueryParser-import XTree-import XQueryOptimizer---{--------------- XPath Steps ---------------------------------------------------------}----- XPath step /tag or /*-child_step :: Tag -> XTree -> XSeq-child_step m x-    = case x of-        (XElem _ _ _ bs)-            -> foldr (\b s -> case b of-                                (XElem k _ _ _) | (k==m || m=="*") -> b:s-                                _ -> s) [] bs-        _ -> []----- XPath step //tag or //*-descendant_step :: Tag -> XTree -> XSeq-descendant_step m (x@(XElem t _ _ cs))-    | m==t || m=="*"-    = x:(concatMap (descendant_step m) cs)-descendant_step m (XElem t _ _ cs) = concatMap (descendant_step m) cs-descendant_step m _ = []----- It's like //* but has tagged children, which are derived statically--- After examing 100 children it gives up: this avoids space leaks-descendant_any_with_tagged_children :: [Tag] -> XTree -> XSeq-descendant_any_with_tagged_children tags (x@(XElem t _ _ cs))-    | all (\tag -> foldr (\b s -> case b of-                                    (XElem k _ _ _) -> s || k == tag-                                    _ -> s) False (take 100 cs)) tags-    = x:(concatMap (descendant_any_with_tagged_children tags) cs)-descendant_any_with_tagged_children tags (XElem t _ _ cs)-    = concatMap (descendant_any_with_tagged_children tags) cs-descendant_any_with_tagged_children tags _ = []----- XPath step /@attr or /@*-attribute_step :: Tag -> XTree -> XSeq-attribute_step m x-    = case x of-        (XElem _ al _ _) -> foldr (\(k,v) s -> if k==m || m=="*"-                                               then (XText v):s-                                               else s) [] al-        _ -> []----- XPath step //@attr or //@*-attribute_descendant_step :: Tag -> XTree -> XSeq-attribute_descendant_step m (x@(XElem _ al _ cs))-    = foldr (\(k,v) s -> if k==m || m=="*"-                         then (XText v):s-                         else s)-            (concatMap (attribute_descendant_step m) cs) al-attribute_descendant_step m _ = []---{------------ Functions --------------------------------------------------------------}----- find the value of a variable in an association list-findV var env-  = case filter (\(n,_) -> n==var) env of-      (_,b):_ -> b-      _ -> error ("Undefined variable: "++var)---- is the variable defined in the association list?-memV var env-  = case filter (\(n,_) -> n==var) env of-      (_,b):_ -> True-      _ -> False----- like foldr but with an index-foldir :: (a -> Int -> b -> b) -> b -> [a] -> Int -> b-foldir c n [] i = n-foldir c n (x:xs) i = c x i (foldir c n xs (i+1))--trueXT = XBool True--readNum :: String -> Maybe XTree-readNum cs = case span isDigit cs of-               (n,[]) -> Just (XInt (read n))-               (n,'.':rest) -> case span isDigit rest of-                                 (k,[]) -> Just (XFloat (read (n++('.':k))))-                                 _ -> Nothing-               _ -> Nothing--text :: XSeq -> XSeq-text xs = foldr (\x r -> case x of-                           XElem _ _ _ [z@(XText _)] -> z:r-                           XElem _ _ _ [z@(XInt _)] -> z:r-                           XElem _ _ _ [z@(XFloat _)] -> z:r-                           XElem _ _ _ [z@(XBool _)] -> z:r-                           XText _ -> x:r-                           XInt _ -> x:r-                           XFloat _ -> x:r-                           XBool _ -> x:r-                           _ -> r) [] xs--toString :: XSeq -> [String]-toString xs = map (\x -> case x of -                           XText t -> t-                           XInt n -> show n-                           XFloat n -> show n-                           XBool n -> show n)-                  (text xs)--toNum :: XSeq -> XSeq-toNum xs = foldr (\x r -> case x of-                            XInt n -> x:r-                            XFloat n -> x:r-                            XText s -> case readNum s of-                                         Just t -> t:r-                                         _ -> r-                            _ -> r) [] (text xs)--toFloat :: XTree -> Float-toFloat (XText s) = case readNum s of-                      Just (XInt n) -> fromIntegral n-                      Just (XFloat n) -> n-                      _ -> error("Cannot convert to a float: "++s)-toFloat (XInt n) = fromIntegral n-toFloat (XFloat n) = n-toFloat x = error("Cannot convert to a float: "++(show x))--contains :: String -> String -> Bool-contains xs ys | ((take (length ys) xs) == ys) = True-contains (_:xs) ys = contains xs ys-contains [] ys = False--distinct :: Eq a => [a] -> [a]-distinct = foldl (\r a -> if elem a r then r else r++[a]) []--arithmetic :: (Float -> Float -> Float) -> XTree -> XTree -> XTree-arithmetic op (XInt n) (XInt m) = XInt (round (op (fromIntegral n) (fromIntegral m)))-arithmetic op (XFloat n) (XFloat m) = XFloat (op n m)-arithmetic op (XFloat n) (XInt m) = XFloat (op n (fromIntegral m))-arithmetic op (XInt n) (XFloat m) = XFloat (op (fromIntegral n) m)--compareXTrees :: XTree -> XTree -> Ordering-compareXTrees (XElem _ _ _ _) _ = EQ-compareXTrees _ (XElem _ _ _ _) = EQ-compareXTrees (XInt n) (XInt m) = compare n m-compareXTrees (XFloat n) (XInt m) = compare n (fromIntegral m)-compareXTrees (XInt n) (XFloat m) = compare (fromIntegral n) m-compareXTrees (XFloat n) (XFloat m) = compare n m-compareXTrees (XText n) (XText m) = compare n m-compareXTrees x y = compare (toFloat x) (toFloat y)--strictCompareOne [XInt n] [XInt m] = compare n m-strictCompareOne [XFloat n] [XFloat m] = compare n m-strictCompareOne [XFloat n] [XInt m] = compare n (fromIntegral m)-strictCompareOne [XInt n] [XFloat m] = compare (fromIntegral n) m-strictCompareOne [XText n] [XText m] = compare n m-strictCompareOne x y = error ("Illegal operands in strict comparison: "++(show x)++" "++(show y))--strictCompare :: XSeq -> XSeq -> Ordering-strictCompare [XElem _ _ _ x] [XElem _ _ _ y] = strictCompareOne x y-strictCompare x [XElem _ _ _ y] = strictCompareOne x y-strictCompare [XElem _ _ _ x] y = strictCompareOne x y-strictCompare x y = strictCompareOne x y--compareXSeqs :: Bool -> XSeq -> XSeq -> Ordering-compareXSeqs ord xs ys-    = let comps = [ compareXTrees x y | x <- xs, y <- ys ]-      in if ord-            then if all (\x -> x == LT) comps-                    then LT-                 else if all (\x -> x == GT) comps-                    then GT-                 else EQ-         else if all (\x -> x == LT) comps-                 then GT-              else if all (\x -> x == GT) comps-                 then LT-              else EQ--conditionTest :: XSeq -> Bool-conditionTest [] = False-conditionTest [XText ""] = False-conditionTest [XInt 0] = False-conditionTest [XBool False] = False-conditionTest _ = True----- XPath steps-paths :: [(Tag,Q Exp)]-paths = [ ( "child_step", [| child_step |] ),-          ( "descendant_step", [| descendant_step |] ),-          ( "attribute_step", [| attribute_step |] ),-          ( "attribute_descendant_step", [| attribute_descendant_step |] )-        ]---type Function = [Q Exp] -> Q Exp---- System functions: they can also be defined as Haskell functions of type (XSeq,...,XSeq) -> XSeq--- but here we make sure they are unfolded and fused with the rest of the query-functions :: [(Tag,Int,Function)]-functions = [ ( "=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] |] ),-              ( "!=", 2, \[xs,ys] -> [| if null [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == EQ ] then [trueXT] else [] |] ),-              ( ">", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == GT ] |] ),-              ( "<", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y == LT ] |] ),-              ( ">=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [GT,EQ] ] |] ),-              ( "<=", 2, \[xs,ys] -> [| [ trueXT | x <- text $xs, y <- text $ys, compareXTrees x y `elem` [LT,EQ] ] |] ),-              ( "eq", 2, \[xs,ys] -> [| if strictCompare $xs $ys == EQ then [trueXT] else [] |] ),-              ( "neq", 2, \[xs,ys] -> [| if strictCompare $xs $ys /= EQ then [trueXT] else [] |] ),-              ( "lt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == LT then [trueXT] else [] |] ),-              ( "gt", 2, \[xs,ys] -> [| if strictCompare $xs $ys == GT then [trueXT] else [] |] ),-              ( "le", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [LT,EQ] then [trueXT] else [] |] ),-              ( "ge", 2, \[xs,ys] -> [| if strictCompare $xs $ys `elem` [GT,EQ] then [trueXT] else [] |] ),-              ( "<<", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox < oy ] |] ),-              ( ">>", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox > oy ] |] ),-              ( "is", 2, \[xs,ys] -> [| [ trueXT | XElem _ _ ox _ <- $xs, XElem _ _ oy _  <- $ys, ox == oy ] |] ),-              ( "+", 2, \[xs,ys] -> [| [ arithmetic (+) x y | x <- toNum $xs, y <- toNum $ys ] |] ),-              ( "-", 2, \[xs,ys] -> [| [ arithmetic (-) x y | x <- toNum $xs, y <- toNum $ys ] |] ),-              ( "*", 2, \[xs,ys] -> [| [ arithmetic (*) x y | x <- toNum $xs, y <- toNum $ys ] |] ),-              ( "div", 2, \[xs,ys] -> [| [ arithmetic (/) x y | x <- toNum $xs, y <- toNum $ys ] |] ),-              ( "idiv", 2, \[xs,ys] -> [| [ XInt (div x y) | (XInt x) <- toNum $xs, (XInt y) <- toNum $ys ] |] ),-              ( "mod", 2, \[xs,ys] -> [| [ XInt (mod x y) | (XInt x) <- toNum $xs, (XInt y) <- toNum $ys ] |] ),-              ( "uplus", 1, \[xs] -> [| [ x | x <- toNum $xs ] |] ),-              ( "uminus", 1, \[xs] -> [| [ case x of XInt n -> XInt (-n); XFloat n -> XFloat (-n) | x <- toNum $xs ] |] ),-              ( "and", 2, \[xs,ys] -> [| if (conditionTest $xs) && (conditionTest $ys) then [trueXT] else [] |] ),-              ( "or", 2, \[xs,ys] -> [| if (conditionTest $xs) || (conditionTest $ys) then [trueXT] else [] |] ),-              ( "not", 1, \[xs] -> [| if (conditionTest $xs) then [] else [trueXT] |] ),-              ( "some", 1, \[xs] -> [| if (conditionTest $xs) then [trueXT] else [] |] ),-              ( "count", 1, \[xs] -> [| [ XInt (length $xs) ] |] ),-              ( "sum", 1, \[xs] -> [| [ XFloat (sum [ toFloat x | x <- toNum $xs ]) ] |] ),-              ( "avg", 1, \[xs] -> [| let ys = $xs in [ XFloat ((sum [ toFloat x | x <- toNum ys ])-                                                                / (fromIntegral (length ys))) ] |] ),-              ( "min", 1, \[xs] -> [| [ XFloat (minimum [ toFloat x | x <- toNum $xs ]) ] |] ),-              ( "max", 1, \[xs] -> [| [ XFloat (maximum [ toFloat x | x <- toNum $xs ]) ] |] ),-              ( "to", 2, \[xs,ys] -> [| [ XInt i | XInt n <- toNum $xs, XInt m <- toNum $ys, i <- [n..m] ] |] ),-              ( "text", 1, \[xs] -> [| text $xs |] ),-              ( "string", 1, \[xs] -> [| text $xs |] ),-              ( "data", 1, \[xs] -> [| text $xs |] ),-              ( "node", 1, \[xs] -> [| $xs |] ),-              ( "empty", 0, \[] -> [| [] |] ),-              ( "true", 0, \[] -> [| [trueXT] |] ),-              ( "false", 0, \[] -> [| [] |] ),-              ( "if", 3, \[cs,ts,es] -> [| if conditionTest $cs then $ts else $es |] ),-              ( "element", 2, \[tags,xs] -> [| [ x | tag <- toString $tags, x@(XElem t _ _ _) <- $xs, (t==tag || tag=="*") ] |] ),-              ( "attribute", 2, \[tags,xs] -> [| [ z | tag <- toString $tags, x <- $xs, z <- attribute_step tag x ] |] ),-              ( "name", 1, \[xs] -> [| [ XText tag | XElem tag _ _ _ <- $xs ] |] ),-              ( "contains", 2, \[xs,text] -> [| [ trueXT | x <- toString $xs, t <- toString $text, contains x t ] |] ),-              ( "concatenate", 2, \[xs,ys] -> [| $xs ++ $ys |] ),-              ( "concat", 2, \[xs,ys] -> [| [ XText (showXS ($xs ++ $ys)) ] |] ),-              ( "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  |] ),-              ( "reverse", 1, \[xs] -> [| reverse $xs |] )-            ]----- functions to be used by the interpreter--- when evaluated, it gives [(String,Int,[XSeq]->XSeq)]-iFunctions :: Q Exp-iFunctions = foldr (\(fname,len,f) r -> let vars = map (\i -> mkName ("v_"++(show i))) [1..len]-                                            entry = tupE [litE (StringL fname),litE (IntegerL (toInteger len)),-                                                          lamE [listP (map varP vars)] (f (map varE vars))]-                                        in [| $entry : $r |]) [| [] |] functions----- XPath steps to be used by the interpreter--- when evaluated, it gives [(String,Tag->XTree->XSeq)]-pFunctions = foldr (\(pname,p) r -> let pn = litE (StringL pname) in [| ($pn,$p) : $r |]) [| [] |] paths----- make a function call-callF :: Tag -> Function-callF fname args = case filter (\(n,_,_) -> n == fname || ("fn:"++n)==fname) functions of-                     (_,len,f):_ -> if (length args) == len-                                       then f args-                                    else error ("wrong number of arguments in function call: " ++ fname)-                     _ ->     -- otherwise, it must be a Haskell function of type (XSeq,...,XSeq) -> XSeq-                          let itp = case args of-                                      [] -> [t| () |]-                                      [_] -> [t| XSeq |]-                                      _ -> foldr (\_ r -> appT r [t| XSeq |]) (appT (tupleT (length args)) [t| XSeq |])-                                                 (tail args)-                              fn = sigE (varE (mkName fname))-                                        (appT (appT arrowT itp) [t| XSeq |])-                          in appE fn (tupE args)---{------------ Compiler ---------------------------------------------------------------}---undef1 = [| error "Undefined XQuery context (.)" |]-undef2 = [| error "Undefined position()" |]-undef3 = [| error "Undefined last()" |]----- does the expression contain a last()?-containsLast :: Ast -> Bool-containsLast (Ast "step" [Ast "call" [Avar "last"]]) = True-containsLast (Ast f _) | elem f ["let","for","predicate"] = False-containsLast (Ast "step" _) = False-containsLast (Ast _ args) = or (map containsLast args)-containsLast _ = False----- calculate the maximum position value used in a predicate, if there is one-maxPosition :: Ast -> Ast -> Int-maxPosition position e-    = case e of-        Ast "call" [Avar f,Ast "step" [p],Aint n]-            | f `elem` ["=","<","<=","eq","lt","le"] && p == position-            -> n-        Ast "call" [Avar f,Aint n,Ast "step" [p]]-            | f `elem` ["=",">",">=","eq","gt","ge"] && p == position-            -> n-        Ast "let" [Avar x,source,body]-            -> if position == Avar x-               then 0 else minp (maxPosition position source) (maxPosition position body)-        Ast "for" [Avar x,Avar i,source,body]-            -> if position == Avar x || position == Avar i-               then 0 else minp (maxPosition position source) (maxPosition position body)-        Ast "predicate" [pred,body]-            -> minp (maxPosition position pred) (maxPosition position body)-        Ast "call" [Avar "and",x,y]-            -> minp (maxPosition position x) (maxPosition position y)-        Ast "call" [Avar "or",x,y]-            -> max (maxPosition position x) (maxPosition position y)-        _ -> 0-    where minp x y = if x == 0 then y else if y == 0 then x else min x y---pathPosition = Ast "call" [Avar "position"]----- Each XPath predicate must calculate position() and last() from its input XSeq--- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)-compilePredicates :: [Ast] -> Q Exp -> Bool -> Q Exp-compilePredicates [] xs _ = xs-compilePredicates ((Aint n):preds) xs _   -- shortcut that improves laziness-    = compilePredicates preds-            [| [ $xs !! $(litE (IntegerL (toInteger (n-1)))) ] |] True-compilePredicates (pred:preds) xs True    -- top-k like-    | maxPosition pathPosition pred > 0-    = compilePredicates (pred:preds)-           [| take $(litE (IntegerL (toInteger (maxPosition pathPosition pred)))) $xs |] False-compilePredicates (pred:preds) xs _-    | containsLast pred         -- blocking: use only when last() is used in the predicate-    = compilePredicates preds-            [| let bl = $xs-                   len = length bl-               in foldir (\x i r -> if case $(compile pred [| x |] [| [XInt i] |] [| [XInt len] |] "") of-                                         [XInt k] -> k == i               -- indexing-                                         b -> conditionTest b-                                    then x:r else r) [] bl 1 |] True-compilePredicates (pred:preds) xs _-    = compilePredicates preds-            [| foldir (\x i r -> if case $(compile pred [| x |] [| [XInt i] |] undef3 "") of-                                      [XInt k] -> k == i               -- indexing-                                      b -> conditionTest b-                                 then x:r else r) [] $xs 1 |] True----- extract the QName-qName :: XSeq -> Tag-qName [XText s] = s-qName e = error ("Invalid QName: "++(show e))----- Compile the AST e into Haskell code--- context: context node (XPath .)--- position: the element position in the parent sequence (XPath position())--- last: the length of the parent sequence (XPath last())--- effective_axis: the XPath axis in /axis::tag(exp)---        (eg, the effective axis of //(A | B) is "descendant_step"-compile :: Ast -> Q Exp -> Q Exp -> Q Exp -> String -> Q Exp-compile e context position last effective_axis-  = case e of-      Avar "." -> [| [ $context :: XTree ] |]-      Avar v -> let x = varE (mkName v)-                in [| $x :: XSeq |]-      Aint n -> let x = litE (IntegerL (toInteger n))-                in [| [ XInt $x ] |]-      Afloat n -> let x = litE (RationalL (toRational n))-                  in [| [ XFloat $x ] |]-      Astring s -> let x = litE (StringL s)-                   in [| [ XText $x ] |]-      Ast "context" [v,Astring dp,body]-          -> [| foldr (\x r -> $(compile body [| x |] position last dp)++r)-                      [] $(compile v context position last effective_axis) |]-      Ast "doc" [Aint n] -> let d = varE (mkName ("_doc"++(show n))) in [| [ $d ] |]-      Ast "call" [Avar "position"]-          -> position-      Ast "call" [Avar "last"]-          -> last-      Ast "step" [Ast "child_step" [tag, Avar "."]]-          | effective_axis /= ""-          -> compile (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last ""-      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)-          -> let bc = compile body context position last effective_axis-                 ts = listE (map (\(Avar tag) -> litE (stringL tag)) tags)-             in [| foldr (\x r -> $(compilePredicates predicates [| descendant_any_with_tagged_children $ts x |] True)++r)-                         [] $bc |]-      Ast "step" ((Ast path_step [Astring tag,body]):predicates)-          |  memV path_step paths-          -> let bc = compile body context position last effective_axis-                 tc = litE (stringL tag)-             in [| foldr (\x r -> $(compilePredicates predicates [| $(findV path_step paths) $tc x |] True)++r)-                         [] $bc |]-      Ast "step" [exp]-          -> compile exp context position last effective_axis-      Ast "step" (exp:predicates)-          -> compilePredicates predicates (compile exp context position last effective_axis) True-      Ast "predicate" [condition,body]-          -> compilePredicates [condition] (compile body context position last effective_axis) True-      Ast "call" ((Avar f):args)-          -> callF f (map (\x -> compile x context position last effective_axis) args)-      Ast "construction" [Astring tag,Ast "attributes" [],body]-          -> let ct = litE (StringL tag)-                 bc = compile body context position last effective_axis-             in [| [ XElem $ct [] 0 $bc ] |]-      Ast "construction" [tag,Ast "attributes" al,body]-          -> let alc = foldr (\(Ast "pair" [a,v]) r-                                  -> let ac = compile a context position last effective_axis-                                         vc = compile v context position last effective_axis-                                     in [| (qName $ac,showXS (text $vc)) : $r |]) [| [] |] al-                 ct = compile tag context position last effective_axis-                 bc = compile body context position last effective_axis-             in [| [ XElem (qName $ct) $alc 0 $bc ] |]-      Ast "let" [Avar var,source,body]-          -> do s <- compile source context position last effective_axis-                b <- compile body context position last effective_axis-                return (AppE (LamE [VarP (mkName var)] b) s)-      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index-          -> let b = compile body [| head $(varE (mkName var)) |] undef2 undef3 ""-                 f = lamE [varP (mkName var)] [| \r -> $b ++ r |]-                 s = compile source context position last effective_axis-             in [| foldr (\x -> $f [x]) [] $s |]-      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index-          -> let b = compile body [| head $(varE (mkName var)) |]-                             [| $(varE (mkName ivar)) |] undef3 ""-                 f = lamE [varP (mkName var)] (lamE [varP (mkName ivar)] [| \r -> $b ++ r |])-                 p = maxPosition (Avar ivar) body-                 ns = if p > 0              -- there is a top-k like restriction-                      then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]-                      else source-                 s = compile ns context position last effective_axis-             in [| foldir (\x i -> $f [x] [XInt i]) [] $s 1 |]-      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting-          -> let res = foldl (\r a -> let ac = compile a context position last effective_axis-                                      in [| $r++[text $ac] |] )-                             [| [ $(compile exp context position last effective_axis) ] |] orderBys-             in [| [ $res ] |]-      Ast "sort" (exp:ordList)                   -- blocking-          -> let ce = compile exp context position last effective_axis-                 ordering = foldr (\(Avar ord) r-                                       -> let asc = if ord == "ascending"-                                                    then [| True |]-                                                    else [| False |]-                                          in [| \(x:xs) (y:ys) -> case compareXSeqs $asc x y of-                                                                    EQ -> $r xs ys-                                                                    o -> o |])-                                  [| \xs ys -> EQ |] ordList-             in [| concatMap head (sortBy (\(_:xs) (_:ys) -> $ordering xs ys) ($ce::[[XSeq]])) |]-      _ -> error ("Illegal XQuery: "++(show e))----- collect all input documents and assign them a unique number-getDocs :: Ast -> Int -> (Ast, Int, [(Int, Ast)])-getDocs query count =-    case query of-      Ast "call" [Avar "doc",file]-             -> (Ast "doc" [Aint count], count+1, [(count,file)])-      Ast "call" [Avar "fn:doc",file]-             -> (Ast "doc" [Aint count], count+1, [(count,file)])-      Ast n args -> let (s,c,ns) = foldr (\a r c -> let (e,c1,n1) = getDocs a c-                                                        (s,c2,n2) = r c1-                                                    in (e:s,c2,docUnion n1 n2))-                                         (\c -> ([],c,[])) args count-                    in (Ast n s,c,ns)-      _ -> (query,count,[])-    where docUnion xs ((n,s):ys) = (n,foldr(\(m,d) r -> if s==d then Aint m else r) s xs):(docUnion xs ys)-          docUnion xs [] = xs----- optimize and compile an AST-compileAst :: Ast -> Q Exp-compileAst ast = compile (optimize ast) undef1 undef2 undef3 ""----- compile an XQuery AST that reads XML documents-compileQuery :: [Ast] -> Q Exp-compileQuery ((Ast "function" ((Avar f):b:args)):xs)-    = let lvars = case args of-                    [Astring a] -> [varP (mkName a)]-                    _ -> [tupP (map (\(Avar a) -> varP (mkName a)) args)]-      in letE [valD (varP (mkName f)) (normalB (lamE lvars (compileAst b))) []]-              (compileQuery xs)-compileQuery ((Ast "variable" [Avar v,u]):xs)-    = letE [valD (varP (mkName v)) (normalB (compileAst u)) []]-           (compileQuery xs)-compileQuery [query]-    = let (ast,_,ns) = getDocs query 0-          code = compileAst ast-      in foldl (\r (n,file) -> let d = lamE [varP (mkName ("_doc"++(show n)))] r-                                       in case file of-                                            Aint m -> [| $d $(varE (mkName ("_doc"++(show m)))) |]-                                            _ -> [| do let [XText f] = $(compileAst file)-                                                       doc <- readFile f-                                                       $d (materialize (parseDocument doc)) |])-               [| return $code |] ns----- Debugging: display the AST and the Haskell code of an input XQuery-cq :: String -> IO ()-cq query = do putStrLn "Abstract Syntax Tree:"-              let ast = parse (scan query)-              putStrLn (show ast)-              let opt = optimize (last ast)-              putStrLn "Optimized AST:"-              putStrLn (show opt)-              putStrLn "Haskell Code:"-              let code = compileQuery ast-              runQ code >>= putStrLn.pprint----- Run an XQuery expression that does not read XML documents--- When evaluated, it returns XSeq-xe :: String -> Q Exp-xe query = compileAst (last (parse (scan query)))----- Run an XQuery that reads XML documents--- When evaluated, it returns IO XSeq-xq :: String -> Q Exp-xq query = compileQuery (parse (scan query))

@@ -1,222 +0,0 @@-{----------------------------------------------------------------------------------------- The XQuery Interpreter-- Programmer: Leonidas Fegaras-- Email: fegaras@cse.uta.edu-- Web: http://lambda.uta.edu/-- Creation: 03/22/08, last update: 05/02/08-- -- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.-- This material is provided as is, with absolutely no warranty expressed or implied.-- Any use is at your own risk. Permission is hereby granted to use or copy this program-- for any purpose, provided the above notices are retained on all copies.-----------------------------------------------------------------------------------------}---{-# OPTIONS_GHC -fth #-}---module XQueryInterpreter where--import List(sortBy)-import XMLParse(parseDocument)-import System.Console.Readline-import XQueryParser-import XTree-import XQueryOptimizer-import XQueryCompiler----- system functions (=, concat, etc)-systemFunctions :: [(String,Int,[XSeq]->XSeq)]-systemFunctions = $(iFunctions)---- XPath step functions (child, descendant, etc)-pathFunctions :: [(String,Tag->XTree->XSeq)]-pathFunctions = $(pFunctions)---- run-time bindings of FLOWR variables-type Environment = [(String,XSeq)]---- a user-defined function is (fname,parameters,body)-type Functions = [(String,[String],Ast)]---undefv1 = error "Undefined XQuery context (.)"-undefv2 = error "Undefined position()"-undefv3 = error "Undefined last()"----- Each XPath predicate must calculate position() and last() from its input XSeq--- if last() is used, then the evaluation is blocking (need to store the whole input XSeq)-applyPredicates :: [Ast] -> XSeq -> Bool -> Environment -> Functions -> XSeq-applyPredicates [] xs _ _ _ = xs-applyPredicates ((Aint n):preds) xs _ env fncs   -- shortcut that improves laziness-    = applyPredicates preds [xs !! (n-1)] True env fncs-applyPredicates (pred:preds) xs True env fncs    -- top-k like-    | maxPosition pathPosition pred > 0-    = applyPredicates (pred:preds) (take (maxPosition pathPosition pred) xs) False env fncs-applyPredicates (pred:preds) xs _ env fncs-    | containsLast pred         -- blocking: use only when last() is used in the predicate-    = let last = length xs-      in applyPredicates preds-             (foldir (\x i r -> if case eval pred x i last "" env fncs of-                                     [XInt k] -> k == i               -- indexing-                                     b -> conditionTest b-                                then x:r else r) [] xs 1) True env fncs-applyPredicates (pred:preds) xs _ env fncs-    = applyPredicates preds-          (foldir (\x i r -> if case eval pred x i undefv3 "" env fncs of-                                  [XInt k] -> k == i               -- indexing-                                  b -> conditionTest b-                             then x:r else r) [] xs 1) True env fncs----- The XQuery interpreter--- context: context node (XPath .)--- position: the element position in the parent sequence (XPath position())--- last: the length of the parent sequence (XPath last())--- effective_axis: the XPath axis in /axis::tag(exp)---        (eg, the effective axis of //(A | B) is "descendant_step"--- env: contains FLOWR variable bindings--- fncs: user-defined functions-eval :: Ast -> XTree -> Int -> Int -> String -> Environment -> Functions -> XSeq-eval e context position last effective_axis env fncs-  = case e of-      Avar "." -> [ context ]-      Avar v -> findV v env-      Aint n -> [ XInt n ]-      Afloat n -> [ XFloat n ]-      Astring s -> [ XText s ]-      Ast "doc" [Aint n] -> findV ("_doc"++(show n)) env-      Ast "context" [v,Astring dp,body]-          -> foldr (\x r -> (eval body x position last dp env fncs)++r)-                   [] (eval v context position last effective_axis env fncs)-      Ast "call" [Avar "position"] -> [XInt position]-      Ast "call" [Avar "last"] -> [XInt last]-      Ast "step" [Ast "child_step" [tag, Avar "."]]-          |  effective_axis /= ""-          -> eval (Ast "step" [Ast effective_axis [tag, Avar "."]]) context position last "" env fncs-      Ast "step" ((Ast "descendant_any" (body:tags)):predicates)-          -> let ts = map (\(Avar tag) -> tag) tags-             in foldr (\x r -> (applyPredicates predicates (descendant_any_with_tagged_children ts x) True env fncs)++r)-                      [] (eval body context position last effective_axis env fncs)-      Ast "step" ((Ast path_step [Astring tag,body]):predicates)-          |  memV path_step pathFunctions-          -> foldr (\x r -> (applyPredicates predicates ((findV path_step pathFunctions) tag x) True env fncs)++r)-                   [] (eval body context position last effective_axis env fncs)-      Ast "step" [exp]-          -> eval exp context position last effective_axis env fncs-      Ast "step" (exp:predicates)-          -> applyPredicates predicates (eval exp context position last effective_axis env fncs) True env fncs-      Ast "predicate" [condition,body]-          -> applyPredicates [condition] (eval body context position last effective_axis env fncs) True env fncs-      Ast "call" ((Avar fname):args)-          -> case filter (\(n,_,_) -> n == fname || ("fn:"++n) == fname) systemFunctions of-               [(_,len,f)] -> if (length args) == len-                              then f (map (\x -> eval x context position last effective_axis env fncs) args)-                              else error ("Wrong number of arguments in system call: "++fname)-               _ -> case filter (\(n,_,_) -> n == fname) fncs of-                      (_,params,body):_ -> if (length params) == (length args)-                                           then eval body context undefv2 undefv3 ""-                                                    ((zipWith (\p a -> (p,eval a context position last effective_axis env fncs))-                                                              params args)++env) fncs-                                           else error ("Wrong number of arguments in function call: "++fname)-                      _ -> error ("Undefined function: "++fname)-      Ast "construction" [Astring tag,Ast "attributes" [],body]-          -> [ XElem tag [] 0 (eval body context position last effective_axis env fncs) ]-      Ast "construction" [tag,Ast "attributes" al,body]-             -> let alc = map (\(Ast "pair" [a,v])-                                     -> let ac = eval a context position last effective_axis env fncs-                                            vc = eval v context position last effective_axis env fncs-                                        in (qName ac,showXS (text vc))) al-                    ct = eval tag context position last effective_axis env fncs-                    bc = eval body context position last effective_axis env fncs-                in [ XElem (qName ct) alc 0 bc ]-      Ast "let" [Avar var,source,body]-          -> eval body context position last effective_axis-                  ((var,eval source context position last effective_axis env fncs):env) fncs-      Ast "for" [Avar var,Avar "$",source,body]      -- a for-loop without an index-          -> foldr (\a r -> (eval body a undefv2 undefv3 "" ((var,[a]):env) fncs)++r)-                   [] (eval source context position last effective_axis env fncs)-      Ast "for" [Avar var,Avar ivar,source,body]     -- a for-loop with an index-          -> let p = maxPosition (Avar ivar) body-                 ns = if p > 0              -- there is a top-k like restriction-                      then Ast "step" [source,Ast "call" [Avar "<=",Ast "step" [pathPosition],Aint p]]-                      else source -             in foldir (\a i r -> (eval body a i undefv3 "" ((var,[a]):(ivar,[XInt i]):env) fncs)++r)-                       [] (eval ns context position last effective_axis env fncs) 1-      Ast "sortTuple" (exp:orderBys)             -- prepare each FLWOR tuple for sorting-          -> [ XElem "" [] 0 (foldl (\r a -> r++[XElem "" [] 0 (text (eval a context position last effective_axis env fncs))])-                                    [XElem "" [] 0 (eval exp context position last effective_axis env fncs)] orderBys) ]-      Ast "sort" (exp:ordList)                   -- blocking-          -> let ce = map (\(XElem _ _ _ xs) -> map (\(XElem _ _ _ ys) -> ys) xs)-                          (eval exp context position last effective_axis env fncs)-                 ordering = foldr (\(Avar ord) r (x:xs) (y:ys)-                                       -> case compareXSeqs (ord == "ascending") x y of-                                            EQ -> r xs ys-                                            o -> o)-                                  (\xs ys -> EQ) ordList-             in concatMap head (sortBy (\(_:xs) (_:ys) -> ordering xs ys) ce)-      _ -> error ("Illegal XQuery: "++(show e))----- evaluate from input continuously-evalInput :: (String -> Environment -> Functions -> IO(Environment,Functions)) -> Environment -> Functions -> IO ()-evalInput eval vs fs-    = do let oneline prompt = do line <- readline prompt-                                 case line of-                                   Nothing -> return "quit"-                                   Just t -> if t == ""-                                             then oneline prompt-                                             else return t-             readlines x = do line <- oneline ": "-                              if last line == '}'-                                 then return (x++" "++(init line))-                                 else if line == "quit"-                                      then return line-                                      else readlines (x++" "++line)-         line <- oneline "> "-         stmt <- if head line == '{'-                 then if last line == '}'-                      then return (init (tail line))-                      else readlines (tail line)-                 else return line-         if stmt == "quit"-            then putStrLn "Bye!"-            else do addHistory stmt-                    (nvs,nfs) <- eval (map (\c -> if c=='\"' then '\'' else c) stmt) vs fs-                    evalInput eval nvs nfs---xqueryE :: String -> Environment -> Functions -> IO (XSeq,Environment,Functions)-xqueryE query variables functions-    = let asts = parse (scan query)-          fncs = foldr (\e r -> case e of-                                  Ast "function" ((Avar f):b:args) -> (f,map (\(Avar v) -> v) args,optimize b):r-                                  _ -> r) functions asts-          vars = foldl (\r e -> case e of-                                  Ast "variable" [Avar v,u] -> (v,eval (optimize u) undefv1 undefv2 undefv3 "" r fncs):r-                                  _ -> r) variables asts-          exprp e = case e of Ast f _ | elem f ["function","variable"] -> True; _ -> False-          (ast,_,ns) = getDocs (concatenateAll (dropWhile exprp asts)) 0-      in do env <- foldr (\(n,s) r -> case s of-                                        Astring file -> do doc <- readFile file-                                                           env <- r-                                                           return (("_doc"++(show n),[materialize (parseDocument doc)]):env)-                                        Aint m -> do env <- r-                                                     return (("_doc"++(show n),findV ("_doc"++(show m)) env):env))-                         (return []) ns-            return (eval (optimize ast) undefv1 undefv2 undefv3 "" (env++vars) fncs,vars,fncs)----- the XQuery interpreter-xquery :: String -> IO XSeq-xquery query = do (u,_,_) <- xqueryE query [] []; return u----- Read an XQuery fom a file and run it-xfile :: String -> IO XSeq-xfile file = do query <- readFile file-                xquery query

@@ -1,156 +0,0 @@-{----------------------------------------------------------------------------------------- Preprocess abstract syntax trees, remove backward steps and optimize-- Programmer: Leonidas Fegaras-- Email: fegaras@cse.uta.edu-- Web: http://lambda.uta.edu/-- Creation: 05/01/08, last update: 05/01/08-- -- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.-- This material is provided as is, with absolutely no warranty expressed or implied.-- Any use is at your own risk. Permission is hereby granted to use or copy this program-- for any purpose, provided the above notices are retained on all copies.-----------------------------------------------------------------------------------------}---module XQueryOptimizer(optimize) where--import XQueryParser(Ast(..))-import XTree---paths = [ "child_step", "descendant_step", "attribute_step", "attribute_descendant_step" ]---distinct :: Eq a => [a] -> [a]-distinct = foldl (\r a -> if elem a r then r else r++[a]) []----- collect attribute constructions inside element constructions-collect_attributes :: Ast -> (Ast,[Ast])-collect_attributes (Ast "attribute_construction" [attr,value])-    = (Ast "call" [Avar "empty"],[Ast "pair" [attr,value]])-collect_attributes (Ast "call" [Avar "concatenate",x,y])-    = let (cx,ax) = collect_attributes x-          (cy,ay) = collect_attributes y-      in (Ast "call" [Avar "concatenate",cx,cy],ax++ay)-collect_attributes (Ast "step" (e:es))-    = let (ce,ae) = collect_attributes e-      in (Ast "step" (ce:es),ae)-collect_attributes e = (e,[])----- does the expression contain a $var/.. ?-parentOfVar :: Ast -> String -> Bool-parentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [Avar x]]]) var = x == var-parentOfVar (Ast "let" [Avar v,s,_]) var | var == v = parentOfVar s var-parentOfVar (Ast "for" [Avar v,Avar i,s,_]) var | var == v || var == i = parentOfVar s var-parentOfVar (Ast _ args) var = or (map (\x -> parentOfVar x var) args)-parentOfVar _ _ = False----- replace $var/.. with $nvar-replaceParentOfVar :: Ast -> String -> String -> Ast-replaceParentOfVar (Ast "step" [Ast "parent_step" [Ast "step" [Avar x]]]) var nvar-    | x == var-    = Avar nvar-replaceParentOfVar (Ast "let" [Avar v,s,b]) var nvar | var == v-    = Ast "let" [Avar v,replaceParentOfVar s var nvar,b]-replaceParentOfVar (Ast "for" [Avar v,Avar i,s,b]) var nvar | var == v || var == i-    = Ast "for" [Avar v,Avar i,replaceParentOfVar s var nvar,b]-replaceParentOfVar (Ast f args) var nvar-    = Ast f (map (\x -> replaceParentOfVar x var nvar) args)-replaceParentOfVar e _ _ = e----- Rules to extract the parent of an XQuery expression--- For every XQuery x and predicates p1 ... pn and for s in [tag,*,@attr]:---    x/s[p1]...[pn]/..   ->  x[s[p1]...[pn]]---    x//s[p1]...[pn]/..  ->  x//*[s[p1]...[pn]]-removeParent :: Ast -> (Ast,Ast,Bool,Ast)-removeParent (Ast "predicate" [c,x])-         = let (nx,cond,childp,tag) = removeParent x-           in (Ast "predicate" [c,nx],cond,childp,tag)-removeParent (Ast "step" ((Ast "child_step" [tag,x]):preds))-    = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),x,True,tag)-removeParent (Ast "step" ((Ast "descendant_step" [tag,x]):preds))-    = (Ast "step" ((Ast "child_step" [tag,Avar "."]):preds),-       Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),True,tag)-removeParent (Ast "step" ((Ast "attribute_step" [tag,x]):preds))-    = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),x,False,tag)-removeParent (Ast "step" ((Ast "descendant_attribute_step" [tag,x]):preds))-    = (Ast "step" ((Ast "attribute_step" [tag,Avar "."]):preds),-       Ast "step" ((Ast "descendant_step" [Astring "*",x]):preds),False,tag)-removeParent (Ast "step" (x:xs))-         = let (nx,cond,childp,tag) = removeParent x-           in (Ast "step" (nx:xs),cond,childp,tag)-removeParent e = error ("Cannot remove this parent step "++(show e))---tagged_children :: String -> Ast -> [Tag]-tagged_children context (Ast "step" ((Ast "child_step" [Astring tag,Avar "."]):_))-    | context == "."-    = [tag]-tagged_children context (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Avar v):_)]):_))-    | v == context-    = [tag]-tagged_children _ (Ast "step" ((Ast step _):_))-    | elem step paths = []-tagged_children context (Ast _ xs) = concatMap (tagged_children context) xs-tagged_children _ _ = []---optimize :: Ast -> Ast--- must be done bottom-up:    /../..-optimize (Ast "step" [Ast "parent_step" [Ast "step" [Ast "parent_step" x]]])-    = let nx = optimize (Ast "step" [Ast "parent_step" x])-      in optimize (Ast "step" [Ast "parent_step" [nx]])--- get rid of a parent step-optimize (Ast "step" [Ast "parent_step" [x]])-    = let (nx,cond,_,_) = removeParent x-      in Ast "predicate" [optimize nx,optimize cond]--- remove $var/.. in a let-FLWOR-optimize (Ast "let" [Avar var,source,body])-    | parentOfVar body var-    = let (nx,cond,childp,tag) = removeParent source-      in optimize (Ast "let" [Avar (var++"_parent"),Ast "predicate" [nx,cond],-                              Ast "let" [Avar var,-                                         Ast "step" [ Ast (if childp-                                                           then "child_step"-                                                           else "attribute_step")-                                                      [tag,Avar (var++"_parent")] ],-                                         replaceParentOfVar body var (var++"_parent")]])--- remove $var/.. from a for-FLWOR-optimize (Ast "for" [Avar var,Avar "$",source,body])-    | parentOfVar body var-    = let (nx,cond,childp,tag) = removeParent source-      in optimize (Ast "for" [Avar (var++"_parent"),Avar "$",Ast "predicate" [nx,cond],-                              Ast "for" [Avar var,Avar "$",-                                         Ast "step" [ Ast (if childp-                                                           then "child_step"-                                                           else "attribute_step")-                                                      [tag,Avar (var++"_parent")] ],-                                         replaceParentOfVar body var (var++"_parent")]])--- pull out attributes from a general element construction-optimize (Ast "element_construction" [tag,content])-    = let (nc,attrs) = collect_attributes content-      in optimize (Ast "construction" [tag,Ast "attributes" attrs,nc])--- if //* collect all children tagnames to use descendant_any_with_tagged_children-optimize (Ast "for" [Avar var,i,Ast "step" [Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds)],body])-    | not (null ((tagged_children var body))) || any (not . null . (tagged_children ".")) preds-    = let ctags = distinct ((tagged_children var body)++(concatMap (tagged_children ".") preds))-          tags = map Avar ctags-      in optimize (Ast "for" [Avar var,i,Ast "step" [Ast "step" ((Ast "descendant_any" (path:tags)):preds)],body])-optimize (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds)]):preds2))-    = let ctags = distinct(tag:(concatMap (tagged_children ".") preds))-          tags = map Avar ctags-      in optimize (Ast "step" ((Ast "child_step" [Astring tag,Ast "step" ((Ast "descendant_any" (path:tags)):preds)]):preds2))-optimize (Ast "step" ((Ast "descendant_step" [Astring "*",path]):preds))-    | any (not . null . (tagged_children ".")) preds-    = let ctags = distinct (concatMap (tagged_children ".") preds)-          tags = map Avar ctags-      in optimize (Ast "step" ((Ast "descendant_any" (path:tags)):preds))--- needs more rules-optimize (Ast n args) = Ast n (map optimize args)-optimize e = e

@@ -1,2080 +0,0 @@-{-# OPTIONS -fglasgow-exts -cpp #-}-module XQueryParser where-import Char-#if __GLASGOW_HASKELL__ >= 503-import Data.Array-#else-import Array-#endif-#if __GLASGOW_HASKELL__ >= 503-import GHC.Exts-#else-import GlaExts-#endif---- parser produced by Happy Version 1.17--newtype HappyAbsSyn  = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = GHC.Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn4 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn4 x = unsafeCoerce# x-{-# INLINE happyIn4 #-}-happyOut4 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut4 x = unsafeCoerce# x-{-# INLINE happyOut4 #-}-happyIn5 :: (Ast) -> (HappyAbsSyn )-happyIn5 x = unsafeCoerce# x-{-# INLINE happyIn5 #-}-happyOut5 :: (HappyAbsSyn ) -> (Ast)-happyOut5 x = unsafeCoerce# x-{-# INLINE happyOut5 #-}-happyIn6 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn6 x = unsafeCoerce# x-{-# INLINE happyIn6 #-}-happyOut6 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut6 x = unsafeCoerce# x-{-# INLINE happyOut6 #-}-happyIn7 :: (Ast) -> (HappyAbsSyn )-happyIn7 x = unsafeCoerce# x-{-# INLINE happyIn7 #-}-happyOut7 :: (HappyAbsSyn ) -> (Ast)-happyOut7 x = unsafeCoerce# x-{-# INLINE happyOut7 #-}-happyIn8 :: (Ast) -> (HappyAbsSyn )-happyIn8 x = unsafeCoerce# x-{-# INLINE happyIn8 #-}-happyOut8 :: (HappyAbsSyn ) -> (Ast)-happyOut8 x = unsafeCoerce# x-{-# INLINE happyOut8 #-}-happyIn9 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn9 x = unsafeCoerce# x-{-# INLINE happyIn9 #-}-happyOut9 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut9 x = unsafeCoerce# x-{-# INLINE happyOut9 #-}-happyIn10 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn10 x = unsafeCoerce# x-{-# INLINE happyIn10 #-}-happyOut10 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut10 x = unsafeCoerce# x-{-# INLINE happyOut10 #-}-happyIn11 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn11 x = unsafeCoerce# x-{-# INLINE happyIn11 #-}-happyOut11 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut11 x = unsafeCoerce# x-{-# INLINE happyOut11 #-}-happyIn12 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn12 x = unsafeCoerce# x-{-# INLINE happyIn12 #-}-happyOut12 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut12 x = unsafeCoerce# x-{-# INLINE happyOut12 #-}-happyIn13 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn13 x = unsafeCoerce# x-{-# INLINE happyIn13 #-}-happyOut13 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut13 x = unsafeCoerce# x-{-# INLINE happyOut13 #-}-happyIn14 :: (( Ast -> Ast, Ast -> Ast )) -> (HappyAbsSyn )-happyIn14 x = unsafeCoerce# x-{-# INLINE happyIn14 #-}-happyOut14 :: (HappyAbsSyn ) -> (( Ast -> Ast, Ast -> Ast ))-happyOut14 x = unsafeCoerce# x-{-# INLINE happyOut14 #-}-happyIn15 :: (( [ Ast ], [ Ast ] )) -> (HappyAbsSyn )-happyIn15 x = unsafeCoerce# x-{-# INLINE happyIn15 #-}-happyOut15 :: (HappyAbsSyn ) -> (( [ Ast ], [ Ast ] ))-happyOut15 x = unsafeCoerce# x-{-# INLINE happyOut15 #-}-happyIn16 :: (Ast) -> (HappyAbsSyn )-happyIn16 x = unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn ) -> (Ast)-happyOut16 x = unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: (Ast) -> (HappyAbsSyn )-happyIn17 x = unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn ) -> (Ast)-happyOut17 x = unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: (Ast) -> (HappyAbsSyn )-happyIn18 x = unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn ) -> (Ast)-happyOut18 x = unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn19 x = unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut19 x = unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn20 x = unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut20 x = unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: ([ Ast ]) -> (HappyAbsSyn )-happyIn21 x = unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn ) -> ([ Ast ])-happyOut21 x = unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: (Ast) -> (HappyAbsSyn )-happyIn22 x = unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn ) -> (Ast)-happyOut22 x = unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn23 x = unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut23 x = unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: (Ast -> Ast) -> (HappyAbsSyn )-happyIn24 x = unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn ) -> (Ast -> Ast)-happyOut24 x = unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: (String -> Ast -> [ Ast ]) -> (HappyAbsSyn )-happyIn25 x = unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn ) -> (String -> Ast -> [ Ast ])-happyOut25 x = unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyIn26 :: (String -> Ast -> Ast) -> (HappyAbsSyn )-happyIn26 x = unsafeCoerce# x-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn ) -> (String -> Ast -> Ast)-happyOut26 x = unsafeCoerce# x-{-# INLINE happyOut26 #-}-happyIn27 :: (String -> Ast -> Ast) -> (HappyAbsSyn )-happyIn27 x = unsafeCoerce# x-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn ) -> (String -> Ast -> Ast)-happyOut27 x = unsafeCoerce# x-{-# INLINE happyOut27 #-}-happyInTok :: Token -> (HappyAbsSyn )-happyInTok x = unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn ) -> Token-happyOutTok x = unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\xbe\x00\xbe\x00\x00\x00\x00\x00\x74\x02\x70\x00\x00\x00\x00\x00\xeb\xff\x00\x00\xfd\xff\x00\x00\x00\x00\x69\x01\x69\x01\xfa\x00\x82\x00\xfa\x00\xfa\x00\x00\x00\x70\x01\xfa\x00\x67\x01\x67\x01\x1c\x00\x16\x00\x37\x00\x84\x01\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xff\x47\x01\x00\x00\x3b\x00\x4f\x01\x46\x01\xff\xff\xfd\xff\x4d\x01\xfa\x00\x7d\x01\x4b\x01\xfa\x00\x7b\x01\x0c\x01\x11\x01\xe0\xff\x0f\x01\x00\x00\xf9\x00\x00\x00\x00\x00\x74\x02\x29\x00\x00\x00\x5a\x01\xf4\xff\xef\xff\x2b\x01\x00\x00\xfa\x00\x4d\x00\x24\x00\x00\x00\x02\x01\xed\x00\xed\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\xfa\x00\x90\x02\x90\x02\x90\x02\xc2\x02\x90\x02\xa9\x02\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\x00\x00\x00\x00\x00\x00\x00\x00\x25\x01\x25\x01\xda\x02\x74\x02\x04\x01\x00\x01\x2c\x01\xee\x00\x00\x00\x19\x00\xfa\x00\x0e\x00\xfb\xff\xe2\x00\x00\x00\x00\x00\x16\x01\x37\x00\x5b\x00\x00\x00\xa2\x01\x00\x00\xd5\x00\xfa\x00\xfa\x00\xfa\x00\x00\x00\xfa\x00\xdb\x00\xfe\x00\xfa\x00\xd2\x00\xd2\x00\xfa\x00\xfa\x00\x1e\x02\x05\x01\xfa\x00\xff\x01\x03\x01\xc6\x00\x08\x00\x00\x00\xd0\x00\xf0\x00\xb2\x00\x00\x00\x04\x00\xfa\x00\x00\x00\x00\x00\xeb\x00\x5f\x00\x00\x00\xe7\x00\x5c\x00\x74\x02\xc2\x00\xb7\x00\x74\x02\x09\x00\xcc\x00\x74\x02\x7f\x01\x74\x02\x74\x02\xde\xff\x00\x00\xda\x00\x37\x00\xda\x00\xc3\x00\x50\x00\x00\x00\xfa\x00\x9f\x00\x00\x00\x00\x00\xfa\x00\xfa\x00\x74\x02\x34\x01\xaa\x00\xc0\x00\x26\x00\x00\x00\x00\x00\xca\x00\xfa\x00\x8f\x00\xfa\x00\xfa\xff\xfa\x00\x00\x00\xfa\x00\xfa\x00\x00\x00\xfa\x00\x00\x00\xfa\x00\x74\x02\x02\x00\x00\x00\xba\x00\xfa\x00\xb8\x00\x7b\x00\x0c\x00\xfe\xff\x74\x02\x74\x02\x58\x02\xfa\x00\x00\x00\x74\x02\x90\x00\x74\x02\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x34\x01\xfa\x00\x3b\x02\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xe0\x01\x00\x00\xc1\x01\x00\x00\x74\x02\x00\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\xa4\x00\x0d\x01\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x9b\x00\x79\x00\x5a\x06\x9c\x03\x4d\x06\x40\x06\x00\x00\x00\x00\x33\x06\x73\x00\x67\x00\x00\x00\x00\x00\x15\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\xa0\x00\x87\x03\x98\x00\x00\x00\x26\x06\x00\x00\x00\x00\x19\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x0c\x06\x12\x01\xbd\x00\x00\x00\x86\x00\x6b\x00\x5d\x00\xff\x05\xf2\x05\xe5\x05\xd8\x05\xcb\x05\xbe\x05\xb1\x05\xa4\x05\x97\x05\x8a\x05\x7d\x05\x70\x05\x63\x05\x56\x05\x49\x05\x3c\x05\x2f\x05\x22\x05\x15\x05\x08\x05\xfb\x04\xee\x04\xe1\x04\xd4\x04\xc7\x04\xba\x04\xad\x04\xa0\x04\x93\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x72\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x71\x00\x86\x04\x79\x04\x6c\x04\x00\x00\x5f\x04\x00\x00\x00\x00\x52\x04\x60\x00\x5a\x00\x45\x04\x5d\x03\x00\x00\x00\x00\x48\x03\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x38\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x03\x00\x00\x00\x00\x00\x00\x1e\x03\x2b\x04\x00\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x04\x2b\x00\x11\x04\x00\x00\x04\x04\x00\x00\xf7\x03\xea\x03\x00\x00\x11\x03\x00\x00\xfc\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x03\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x00\x00\x00\x00\x00\x00\x07\x00\xb6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\x00\x00\x00\x00\x00\x00\x8e\xff\xfa\xff\xbd\xff\xed\xff\xee\xff\x00\x00\xef\xff\x9e\xff\x93\xff\x91\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\xff\x00\x00\x8d\xff\xf4\xff\xcc\xff\xcb\xff\xcd\xff\x00\x00\xfe\xff\xfd\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\xff\x00\x00\xc8\xff\xce\xff\xac\xff\xcf\xff\xd0\xff\xca\xff\x00\x00\x8b\xff\x00\x00\x00\x00\x00\x00\x9c\xff\x9a\xff\x00\x00\x00\x00\x00\x00\xb1\xff\xbb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xff\xd2\xff\xd3\xff\xd4\xff\xd5\xff\xd6\xff\xd7\xff\xd8\xff\xd9\xff\xda\xff\xdb\xff\xdc\xff\xdd\xff\xde\xff\xdf\xff\xe0\xff\xe1\xff\xe2\xff\xe3\xff\xe4\xff\xe5\xff\xe6\xff\xe7\xff\xe8\xff\xe9\xff\xea\xff\xeb\xff\xec\xff\xbe\xff\xc5\xff\xc6\xff\x00\x00\x00\x00\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xff\xa9\xff\x98\xff\x00\x00\x00\x00\x94\xff\x00\x00\x99\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xff\x00\x00\xab\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x89\xff\x00\x00\x00\x00\xfc\xff\xfb\xff\x00\x00\x00\x00\x8a\xff\xb4\xff\x00\x00\x00\x00\xb5\xff\x00\x00\x00\x00\xc0\xff\x00\x00\x00\x00\xc4\xff\x00\x00\x00\x00\xc9\xff\x00\x00\xf1\xff\xf2\xff\x00\x00\x92\xff\x96\xff\x00\x00\x97\xff\x00\x00\x00\x00\xa3\xff\x00\x00\x00\x00\xa4\xff\xa5\xff\x00\x00\x00\x00\xf3\xff\xb6\xff\xbc\xff\x00\x00\x00\x00\xaa\xff\xb2\xff\x95\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\xae\xff\x00\x00\xad\xff\x00\x00\xf9\xff\x00\x00\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\xff\xc3\xff\x00\x00\x00\x00\xa0\xff\xf0\xff\x00\x00\xc2\xff\xa6\xff\xb3\xff\x00\x00\xba\xff\xb8\xff\xb7\xff\xb6\xff\x00\x00\x00\x00\xa1\xff\xb0\xff\xaf\xff\xf5\xff\x00\x00\x00\x00\xf7\xff\x00\x00\x9f\xff\xc1\xff\xb9\xff\xf8\xff"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x02\x00\x03\x00\x04\x00\x07\x00\x1a\x00\x0b\x00\x0d\x00\x09\x00\x0a\x00\x0c\x00\x2d\x00\x0a\x00\x2d\x00\x0a\x00\x10\x00\x11\x00\x12\x00\x0a\x00\x0c\x00\x43\x00\x03\x00\x0d\x00\x18\x00\x0c\x00\x0b\x00\x49\x00\x0e\x00\x0f\x00\x2e\x00\x40\x00\x09\x00\x40\x00\x0b\x00\x2e\x00\x38\x00\x0b\x00\x09\x00\x27\x00\x0b\x00\x39\x00\x0c\x00\x2b\x00\x2c\x00\x2e\x00\x39\x00\x03\x00\x0b\x00\x2e\x00\x18\x00\x0c\x00\x0a\x00\x35\x00\x36\x00\x2e\x00\x3c\x00\x3b\x00\x3a\x00\x2e\x00\x3c\x00\x18\x00\x02\x00\x03\x00\x04\x00\x09\x00\x42\x00\x48\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x44\x00\x12\x00\x3c\x00\x10\x00\x11\x00\x12\x00\x35\x00\x36\x00\x37\x00\x48\x00\x3c\x00\x18\x00\x2e\x00\x14\x00\x09\x00\x2e\x00\x3c\x00\x35\x00\x36\x00\x37\x00\x0c\x00\x03\x00\x45\x00\x12\x00\x03\x00\x48\x00\x27\x00\x03\x00\x09\x00\x08\x00\x2b\x00\x2c\x00\x0c\x00\x45\x00\x03\x00\x0c\x00\x48\x00\x12\x00\x03\x00\x08\x00\x35\x00\x36\x00\x07\x00\x3c\x00\x03\x00\x3a\x00\x03\x00\x3c\x00\x3d\x00\x42\x00\x07\x00\x44\x00\x03\x00\x42\x00\x2e\x00\x44\x00\x07\x00\x46\x00\x47\x00\x48\x00\x02\x00\x03\x00\x04\x00\x3a\x00\x3b\x00\x3c\x00\x2e\x00\x09\x00\x0a\x00\x2e\x00\x41\x00\x42\x00\x0a\x00\x44\x00\x10\x00\x11\x00\x12\x00\x3a\x00\x11\x00\x3c\x00\x02\x00\x03\x00\x18\x00\x2b\x00\x2c\x00\x42\x00\x03\x00\x44\x00\x30\x00\x14\x00\x07\x00\x03\x00\x00\x00\x01\x00\x09\x00\x03\x00\x04\x00\x27\x00\x06\x00\x13\x00\x14\x00\x2b\x00\x2c\x00\x13\x00\x14\x00\x0d\x00\x0e\x00\x0f\x00\x3e\x00\x3f\x00\x12\x00\x35\x00\x36\x00\x15\x00\x16\x00\x17\x00\x3a\x00\x2d\x00\x3c\x00\x44\x00\x02\x00\x03\x00\x04\x00\x0b\x00\x42\x00\x0b\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x0e\x00\x0f\x00\x10\x00\x10\x00\x11\x00\x12\x00\x07\x00\x01\x00\x44\x00\x03\x00\x04\x00\x18\x00\x06\x00\x2e\x00\x03\x00\x1a\x00\x3c\x00\x03\x00\x1a\x00\x0d\x00\x0e\x00\x0f\x00\x07\x00\x16\x00\x12\x00\x2d\x00\x27\x00\x15\x00\x16\x00\x17\x00\x2b\x00\x2c\x00\x15\x00\x16\x00\x17\x00\x15\x00\x16\x00\x17\x00\x2f\x00\x0b\x00\x35\x00\x36\x00\x03\x00\x0b\x00\x45\x00\x3a\x00\x09\x00\x3c\x00\x3d\x00\x02\x00\x03\x00\x04\x00\x2f\x00\x42\x00\x3b\x00\x44\x00\x09\x00\x46\x00\x47\x00\x48\x00\x15\x00\x16\x00\x17\x00\x10\x00\x11\x00\x12\x00\x0a\x00\x01\x00\x0a\x00\x03\x00\x04\x00\x18\x00\x06\x00\x16\x00\x03\x00\x44\x00\x3c\x00\x03\x00\x44\x00\x0d\x00\x0e\x00\x0f\x00\x07\x00\x3c\x00\x12\x00\x32\x00\x27\x00\x15\x00\x16\x00\x17\x00\x2b\x00\x2c\x00\x15\x00\x16\x00\x17\x00\x15\x00\x16\x00\x17\x00\x01\x00\x2e\x00\x35\x00\x36\x00\x44\x00\x2e\x00\x31\x00\x3a\x00\x3c\x00\x3c\x00\x12\x00\x13\x00\x14\x00\x15\x00\x2f\x00\x42\x00\x2e\x00\x44\x00\x2e\x00\x46\x00\x47\x00\x48\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x05\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x3b\x00\x33\x00\x34\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x06\x00\x0b\x00\x3c\x00\x0b\x00\x3c\x00\x44\x00\x3c\x00\x45\x00\x09\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x08\x00\x44\x00\x3c\x00\x44\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0c\x00\xff\xff\xff\xff\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\xff\xff\x27\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\x0b\x00\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\x03\x00\x04\x00\x12\x00\x06\x00\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x0e\x00\x0f\x00\x10\x00\x41\x00\x43\x00\x2c\x00\xee\x00\x11\x00\xa8\x00\xfd\x00\xd6\x00\xe7\x00\x9c\x00\xe5\x00\x12\x00\x13\x00\x14\x00\xaf\x00\x05\x01\x26\x00\xfe\x00\xda\x00\x15\x00\xfe\x00\x2f\x00\xff\xff\xc6\x00\x08\x00\x94\x00\xd7\x00\x2b\x00\x9d\x00\x2c\x00\x94\x00\x44\x00\xc8\x00\x2e\x00\x16\x00\x2f\x00\x95\x00\xf5\x00\x17\x00\x18\x00\x99\x00\x96\x00\xf0\x00\x88\x00\xe8\x00\x15\x00\xf3\x00\x98\x00\x19\x00\x1a\x00\x99\x00\x2d\x00\x42\x00\x1b\x00\x99\x00\x1c\x00\x15\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x1e\x00\xef\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\x1f\x00\x14\x00\x30\x00\x12\x00\x13\x00\x14\x00\x89\x00\x8a\x00\xc9\x00\xdb\x00\x2d\x00\x15\x00\x99\x00\x92\x00\x11\x00\x99\x00\x30\x00\x89\x00\x8a\x00\x8b\x00\xd3\x00\xb6\x00\xca\x00\x14\x00\x30\x00\xcb\x00\x16\x00\xb7\x00\x11\x00\x81\x00\x17\x00\x18\x00\xde\x00\x8c\x00\x30\x00\xe0\x00\x8d\x00\x14\x00\x32\x00\x31\x00\x19\x00\x1a\x00\x82\x00\x1c\x00\xbf\x00\x1b\x00\x32\x00\x1c\x00\x1d\x00\x1e\x00\x33\x00\x1f\x00\x32\x00\x1e\x00\x99\x00\x1f\x00\x3c\x00\x20\x00\x21\x00\x22\x00\x0e\x00\x0f\x00\x10\x00\x8f\x00\x90\x00\x1c\x00\x99\x00\x11\x00\x3b\x00\x99\x00\x91\x00\x1e\x00\x83\x00\x1f\x00\x12\x00\x13\x00\x14\x00\xc3\x00\x99\x00\x1c\x00\xe2\x00\xe3\x00\x15\x00\x46\x00\x47\x00\x1e\x00\x32\x00\x1f\x00\x48\x00\x92\x00\x3d\x00\xa8\x00\x22\x00\x23\x00\x44\x00\x03\x00\x04\x00\x16\x00\x05\x00\xa5\x00\x3f\x00\x17\x00\x18\x00\x3e\x00\x3f\x00\x06\x00\x07\x00\x08\x00\x27\x00\x28\x00\x09\x00\x19\x00\x1a\x00\x0a\x00\x0b\x00\x0c\x00\x1b\x00\xfa\x00\x1c\x00\x1f\x00\x0e\x00\x0f\x00\x10\x00\x00\x01\x1e\x00\xe6\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\x85\x00\x08\x00\x86\x00\x12\x00\x13\x00\x14\x00\x41\x00\xaa\x00\x1f\x00\x03\x00\x04\x00\x15\x00\x05\x00\xf5\x00\x03\x00\xf4\x00\xd1\x00\x03\x00\xd4\x00\x06\x00\x07\x00\x08\x00\x41\x00\xd9\x00\x09\x00\xdc\x00\x16\x00\x0a\x00\x0b\x00\x0c\x00\x17\x00\x18\x00\xd4\x00\x0b\x00\x0c\x00\xc1\x00\x0b\x00\x0c\x00\xdd\x00\xdf\x00\x19\x00\x1a\x00\x03\x00\xe1\x00\xac\x00\x1b\x00\xad\x00\x1c\x00\x1d\x00\x0e\x00\x0f\x00\x10\x00\xae\x00\x1e\x00\x42\x00\x1f\x00\x11\x00\x20\x00\x21\x00\x22\x00\xc3\x00\x0b\x00\x0c\x00\x12\x00\x13\x00\x14\x00\xb0\x00\x02\x00\xb3\x00\x03\x00\x04\x00\x15\x00\x05\x00\xba\x00\x03\x00\x1f\x00\xbb\x00\x03\x00\x1f\x00\x06\x00\x07\x00\x08\x00\x41\x00\xc5\x00\x09\x00\xcc\x00\x16\x00\x0a\x00\x0b\x00\x0c\x00\x17\x00\x18\x00\x8d\x00\x0b\x00\x0c\x00\x29\x00\x0b\x00\x0c\x00\xcd\x00\x94\x00\x19\x00\x1a\x00\x1f\x00\x9e\x00\x85\x00\x1b\x00\x9b\x00\x1c\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x9f\x00\x1e\x00\x94\x00\x1f\x00\x9e\x00\x20\x00\x21\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x97\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x42\x00\xf7\x00\xf8\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xd8\x00\xa0\x00\xa2\x00\xa3\x00\xa5\x00\x1f\x00\xaa\x00\x25\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xc1\x00\x1f\x00\x36\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x07\x01\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x02\x01\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xb1\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xb4\x00\x00\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x04\x01\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xfc\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x00\x00\x61\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x03\x00\x38\x00\xe8\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xe9\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xce\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\xcf\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xd1\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xb1\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xb4\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xc5\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\xa6\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x03\x00\x38\x00\x39\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x02\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x04\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xf8\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xfa\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x00\x01\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xea\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xeb\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xec\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xef\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xf1\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xcd\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xe1\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xb5\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xb8\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbb\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbc\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbd\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xbe\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x64\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x65\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x66\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x67\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x68\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x69\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6a\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6c\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6d\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6e\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x6f\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x70\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x71\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x72\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x73\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x74\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x75\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x76\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x77\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x78\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x79\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7a\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7c\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7d\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7e\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x7f\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x80\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x91\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xa0\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\xa3\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x34\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x36\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x37\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x03\x00\x3b\x00\x09\x00\x05\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x06\x00\x07\x00\x08\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x0a\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--happyReduceArr = array (1, 118) [-	(1 , happyReduce_1),-	(2 , happyReduce_2),-	(3 , happyReduce_3),-	(4 , happyReduce_4),-	(5 , happyReduce_5),-	(6 , happyReduce_6),-	(7 , happyReduce_7),-	(8 , happyReduce_8),-	(9 , happyReduce_9),-	(10 , happyReduce_10),-	(11 , happyReduce_11),-	(12 , happyReduce_12),-	(13 , happyReduce_13),-	(14 , happyReduce_14),-	(15 , happyReduce_15),-	(16 , happyReduce_16),-	(17 , happyReduce_17),-	(18 , happyReduce_18),-	(19 , happyReduce_19),-	(20 , happyReduce_20),-	(21 , happyReduce_21),-	(22 , happyReduce_22),-	(23 , happyReduce_23),-	(24 , happyReduce_24),-	(25 , happyReduce_25),-	(26 , happyReduce_26),-	(27 , happyReduce_27),-	(28 , happyReduce_28),-	(29 , happyReduce_29),-	(30 , happyReduce_30),-	(31 , happyReduce_31),-	(32 , happyReduce_32),-	(33 , happyReduce_33),-	(34 , happyReduce_34),-	(35 , happyReduce_35),-	(36 , happyReduce_36),-	(37 , happyReduce_37),-	(38 , happyReduce_38),-	(39 , happyReduce_39),-	(40 , happyReduce_40),-	(41 , happyReduce_41),-	(42 , happyReduce_42),-	(43 , happyReduce_43),-	(44 , happyReduce_44),-	(45 , happyReduce_45),-	(46 , happyReduce_46),-	(47 , happyReduce_47),-	(48 , happyReduce_48),-	(49 , happyReduce_49),-	(50 , happyReduce_50),-	(51 , happyReduce_51),-	(52 , happyReduce_52),-	(53 , happyReduce_53),-	(54 , happyReduce_54),-	(55 , happyReduce_55),-	(56 , happyReduce_56),-	(57 , happyReduce_57),-	(58 , happyReduce_58),-	(59 , happyReduce_59),-	(60 , happyReduce_60),-	(61 , happyReduce_61),-	(62 , happyReduce_62),-	(63 , happyReduce_63),-	(64 , happyReduce_64),-	(65 , happyReduce_65),-	(66 , happyReduce_66),-	(67 , happyReduce_67),-	(68 , happyReduce_68),-	(69 , happyReduce_69),-	(70 , happyReduce_70),-	(71 , happyReduce_71),-	(72 , happyReduce_72),-	(73 , happyReduce_73),-	(74 , happyReduce_74),-	(75 , happyReduce_75),-	(76 , happyReduce_76),-	(77 , happyReduce_77),-	(78 , happyReduce_78),-	(79 , happyReduce_79),-	(80 , happyReduce_80),-	(81 , happyReduce_81),-	(82 , happyReduce_82),-	(83 , happyReduce_83),-	(84 , happyReduce_84),-	(85 , happyReduce_85),-	(86 , happyReduce_86),-	(87 , happyReduce_87),-	(88 , happyReduce_88),-	(89 , happyReduce_89),-	(90 , happyReduce_90),-	(91 , happyReduce_91),-	(92 , happyReduce_92),-	(93 , happyReduce_93),-	(94 , happyReduce_94),-	(95 , happyReduce_95),-	(96 , happyReduce_96),-	(97 , happyReduce_97),-	(98 , happyReduce_98),-	(99 , happyReduce_99),-	(100 , happyReduce_100),-	(101 , happyReduce_101),-	(102 , happyReduce_102),-	(103 , happyReduce_103),-	(104 , happyReduce_104),-	(105 , happyReduce_105),-	(106 , happyReduce_106),-	(107 , happyReduce_107),-	(108 , happyReduce_108),-	(109 , happyReduce_109),-	(110 , happyReduce_110),-	(111 , happyReduce_111),-	(112 , happyReduce_112),-	(113 , happyReduce_113),-	(114 , happyReduce_114),-	(115 , happyReduce_115),-	(116 , happyReduce_116),-	(117 , happyReduce_117),-	(118 , happyReduce_118)-	]--happy_n_terms = 74 :: Int-happy_n_nonterms = 24 :: Int--happyReduce_1 = happySpecReduce_1  0# happyReduction_1-happyReduction_1 happy_x_1-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> -	happyIn4-		 ([happy_var_1]-	)}--happyReduce_2 = happySpecReduce_2  0# happyReduction_2-happyReduction_2 happy_x_2-	happy_x_1-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> -	happyIn4-		 ([happy_var_1]-	)}--happyReduce_3 = happySpecReduce_3  0# happyReduction_3-happyReduction_3 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut4 happy_x_1 of { happy_var_1 -> -	case happyOut5 happy_x_3 of { happy_var_3 -> -	happyIn4-		 (happy_var_1++[happy_var_3]-	)}}--happyReduce_4 = happyReduce 4# 0# happyReduction_4-happyReduction_4 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut4 happy_x_1 of { happy_var_1 -> -	case happyOut5 happy_x_3 of { happy_var_3 -> -	happyIn4-		 (happy_var_1++[happy_var_3]-	) `HappyStk` happyRest}}--happyReduce_5 = happySpecReduce_1  1# happyReduction_5-happyReduction_5 happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	happyIn5-		 (happy_var_1-	)}--happyReduce_6 = happyReduce 5# 1# happyReduction_6-happyReduction_6 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut7 happy_x_3 of { happy_var_3 -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn5-		 (Ast "variable" [happy_var_3,happy_var_5]-	) `HappyStk` happyRest}}--happyReduce_7 = happyReduce 9# 1# happyReduction_7-happyReduction_7 (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 happyOut6 happy_x_5 of { happy_var_5 -> -	case happyOut8 happy_x_8 of { happy_var_8 -> -	happyIn5-		 (Ast "function" ([Avar happy_var_3,happy_var_8]++happy_var_5)-	) `HappyStk` happyRest}}}--happyReduce_8 = happyReduce 8# 1# happyReduction_8-happyReduction_8 (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 happyOut8 happy_x_7 of { happy_var_7 -> -	happyIn5-		 (Ast "function" [Avar happy_var_3,happy_var_7]-	) `HappyStk` happyRest}}--happyReduce_9 = happySpecReduce_1  2# happyReduction_9-happyReduction_9 happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	happyIn6-		 ([happy_var_1]-	)}--happyReduce_10 = happySpecReduce_3  2# happyReduction_10-happyReduction_10 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 -> -	happyIn6-		 (happy_var_1++[happy_var_3]-	)}}--happyReduce_11 = happySpecReduce_1  3# happyReduction_11-happyReduction_11 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Variable happy_var_1) -> -	happyIn7-		 (Avar happy_var_1-	)}--happyReduce_12 = happyReduce 5# 4# happyReduction_12-happyReduction_12 (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 happyOut13 happy_x_2 of { happy_var_2 -> -	case happyOut14 happy_x_3 of { happy_var_3 -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn8-		 ((snd happy_var_3) (happy_var_1 (happy_var_2 ((fst happy_var_3) happy_var_5)))-	) `HappyStk` happyRest}}}}--happyReduce_13 = happyReduce 4# 4# happyReduction_13-happyReduction_13 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut11 happy_x_2 of { happy_var_2 -> -	case happyOut8 happy_x_4 of { happy_var_4 -> -	happyIn8-		 (call "some" [happy_var_2 happy_var_4]-	) `HappyStk` happyRest}}--happyReduce_14 = happyReduce 4# 4# happyReduction_14-happyReduction_14 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut11 happy_x_2 of { happy_var_2 -> -	case happyOut8 happy_x_4 of { happy_var_4 -> -	happyIn8-		 (call "not" [call "some" [happy_var_2 (call "not" [happy_var_4])]]-	) `HappyStk` happyRest}}--happyReduce_15 = happyReduce 6# 4# happyReduction_15-happyReduction_15 (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 happyOut8 happy_x_2 of { happy_var_2 -> -	case happyOut8 happy_x_4 of { happy_var_4 -> -	case happyOut8 happy_x_6 of { happy_var_6 -> -	happyIn8-		 (call "if" [happy_var_2,happy_var_4,happy_var_6]-	) `HappyStk` happyRest}}}--happyReduce_16 = happySpecReduce_1  4# happyReduction_16-happyReduction_16 happy_x_1-	 =  case happyOut22 happy_x_1 of { happy_var_1 -> -	happyIn8-		 (happy_var_1-	)}--happyReduce_17 = happySpecReduce_1  4# happyReduction_17-happyReduction_17 happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	happyIn8-		 (happy_var_1-	)}--happyReduce_18 = happySpecReduce_1  4# happyReduction_18-happyReduction_18 happy_x_1-	 =  case happyOut17 happy_x_1 of { happy_var_1 -> -	happyIn8-		 (happy_var_1-	)}--happyReduce_19 = happySpecReduce_3  4# happyReduction_19-happyReduction_19 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "to" [happy_var_1,happy_var_3]-	)}}--happyReduce_20 = happySpecReduce_3  4# happyReduction_20-happyReduction_20 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "+" [happy_var_1,happy_var_3]-	)}}--happyReduce_21 = happySpecReduce_3  4# happyReduction_21-happyReduction_21 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "-" [happy_var_1,happy_var_3]-	)}}--happyReduce_22 = happySpecReduce_3  4# happyReduction_22-happyReduction_22 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "*" [happy_var_1,happy_var_3]-	)}}--happyReduce_23 = happySpecReduce_3  4# happyReduction_23-happyReduction_23 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "div" [happy_var_1,happy_var_3]-	)}}--happyReduce_24 = happySpecReduce_3  4# happyReduction_24-happyReduction_24 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "idiv" [happy_var_1,happy_var_3]-	)}}--happyReduce_25 = happySpecReduce_3  4# happyReduction_25-happyReduction_25 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "mod" [happy_var_1,happy_var_3]-	)}}--happyReduce_26 = happySpecReduce_3  4# happyReduction_26-happyReduction_26 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "=" [happy_var_1,happy_var_3]-	)}}--happyReduce_27 = happySpecReduce_3  4# happyReduction_27-happyReduction_27 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "!=" [happy_var_1,happy_var_3]-	)}}--happyReduce_28 = happySpecReduce_3  4# happyReduction_28-happyReduction_28 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "<" [happy_var_1,happy_var_3]-	)}}--happyReduce_29 = happySpecReduce_3  4# happyReduction_29-happyReduction_29 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "<=" [happy_var_1,happy_var_3]-	)}}--happyReduce_30 = happySpecReduce_3  4# happyReduction_30-happyReduction_30 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call ">" [happy_var_1,happy_var_3]-	)}}--happyReduce_31 = happySpecReduce_3  4# happyReduction_31-happyReduction_31 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call ">=" [happy_var_1,happy_var_3]-	)}}--happyReduce_32 = happySpecReduce_3  4# happyReduction_32-happyReduction_32 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "<<" [happy_var_1,happy_var_3]-	)}}--happyReduce_33 = happySpecReduce_3  4# happyReduction_33-happyReduction_33 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call ">>" [happy_var_1,happy_var_3]-	)}}--happyReduce_34 = happySpecReduce_3  4# happyReduction_34-happyReduction_34 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "is" [happy_var_1,happy_var_3]-	)}}--happyReduce_35 = happySpecReduce_3  4# happyReduction_35-happyReduction_35 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "eq" [happy_var_1,happy_var_3]-	)}}--happyReduce_36 = happySpecReduce_3  4# happyReduction_36-happyReduction_36 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "ne" [happy_var_1,happy_var_3]-	)}}--happyReduce_37 = happySpecReduce_3  4# happyReduction_37-happyReduction_37 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "lt" [happy_var_1,happy_var_3]-	)}}--happyReduce_38 = happySpecReduce_3  4# happyReduction_38-happyReduction_38 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "le" [happy_var_1,happy_var_3]-	)}}--happyReduce_39 = happySpecReduce_3  4# happyReduction_39-happyReduction_39 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "gt" [happy_var_1,happy_var_3]-	)}}--happyReduce_40 = happySpecReduce_3  4# happyReduction_40-happyReduction_40 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "ge" [happy_var_1,happy_var_3]-	)}}--happyReduce_41 = happySpecReduce_3  4# happyReduction_41-happyReduction_41 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "and" [happy_var_1,happy_var_3]-	)}}--happyReduce_42 = happySpecReduce_3  4# happyReduction_42-happyReduction_42 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "or" [happy_var_1,happy_var_3]-	)}}--happyReduce_43 = happySpecReduce_3  4# happyReduction_43-happyReduction_43 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "not" [happy_var_1,happy_var_3]-	)}}--happyReduce_44 = happySpecReduce_3  4# happyReduction_44-happyReduction_44 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "union" [happy_var_1,happy_var_3]-	)}}--happyReduce_45 = happySpecReduce_3  4# happyReduction_45-happyReduction_45 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "intersect" [happy_var_1,happy_var_3]-	)}}--happyReduce_46 = happySpecReduce_3  4# happyReduction_46-happyReduction_46 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn8-		 (call "except" [happy_var_1,happy_var_3]-	)}}--happyReduce_47 = happySpecReduce_2  4# happyReduction_47-happyReduction_47 happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_2 of { happy_var_2 -> -	happyIn8-		 (call "uplus" [happy_var_2]-	)}--happyReduce_48 = happySpecReduce_2  4# happyReduction_48-happyReduction_48 happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_2 of { happy_var_2 -> -	happyIn8-		 (call "uminus" [happy_var_2]-	)}--happyReduce_49 = happySpecReduce_2  4# happyReduction_49-happyReduction_49 happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_2 of { happy_var_2 -> -	happyIn8-		 (call "not" [happy_var_2]-	)}--happyReduce_50 = happySpecReduce_1  4# happyReduction_50-happyReduction_50 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TString happy_var_1) -> -	happyIn8-		 (Astring happy_var_1-	)}--happyReduce_51 = happySpecReduce_1  4# happyReduction_51-happyReduction_51 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TInteger happy_var_1) -> -	happyIn8-		 (Aint happy_var_1-	)}--happyReduce_52 = happySpecReduce_1  4# happyReduction_52-happyReduction_52 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TFloat happy_var_1) -> -	happyIn8-		 (Afloat happy_var_1-	)}--happyReduce_53 = happySpecReduce_1  5# happyReduction_53-happyReduction_53 happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	happyIn9-		 ([happy_var_1]-	)}--happyReduce_54 = happySpecReduce_3  5# happyReduction_54-happyReduction_54 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut9 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn9-		 (happy_var_1++[happy_var_3]-	)}}--happyReduce_55 = happySpecReduce_2  6# happyReduction_55-happyReduction_55 happy_x_2-	happy_x_1-	 =  case happyOut11 happy_x_2 of { happy_var_2 -> -	happyIn10-		 (happy_var_2-	)}--happyReduce_56 = happySpecReduce_2  6# happyReduction_56-happyReduction_56 happy_x_2-	happy_x_1-	 =  case happyOut12 happy_x_2 of { happy_var_2 -> -	happyIn10-		 (happy_var_2-	)}--happyReduce_57 = happySpecReduce_3  6# happyReduction_57-happyReduction_57 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut10 happy_x_1 of { happy_var_1 -> -	case happyOut11 happy_x_3 of { happy_var_3 -> -	happyIn10-		 (happy_var_1 . happy_var_3-	)}}--happyReduce_58 = happySpecReduce_3  6# happyReduction_58-happyReduction_58 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut10 happy_x_1 of { happy_var_1 -> -	case happyOut12 happy_x_3 of { happy_var_3 -> -	happyIn10-		 (happy_var_1 . happy_var_3-	)}}--happyReduce_59 = happySpecReduce_3  7# happyReduction_59-happyReduction_59 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn11-		 (\x -> Ast "for" [happy_var_1,Avar "$",happy_var_3,x]-	)}}--happyReduce_60 = happyReduce 5# 7# happyReduction_60-happyReduction_60 (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_1 of { happy_var_1 -> -	case happyOut7 happy_x_3 of { happy_var_3 -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn11-		 (\x -> Ast "for" [happy_var_1,happy_var_3,happy_var_5,x]-	) `HappyStk` happyRest}}}--happyReduce_61 = happyReduce 5# 7# happyReduction_61-happyReduction_61 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut11 happy_x_1 of { happy_var_1 -> -	case happyOut7 happy_x_3 of { happy_var_3 -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn11-		 (\x -> happy_var_1(Ast "for" [happy_var_3,Avar "$",happy_var_5,x])-	) `HappyStk` happyRest}}}--happyReduce_62 = happyReduce 7# 7# happyReduction_62-happyReduction_62 (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 happyOut11 happy_x_1 of { happy_var_1 -> -	case happyOut7 happy_x_3 of { happy_var_3 -> -	case happyOut7 happy_x_5 of { happy_var_5 -> -	case happyOut8 happy_x_7 of { happy_var_7 -> -	happyIn11-		 (\x -> happy_var_1(Ast "for" [happy_var_3,happy_var_5,happy_var_7,x])-	) `HappyStk` happyRest}}}}--happyReduce_63 = happySpecReduce_3  8# happyReduction_63-happyReduction_63 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn12-		 (\x -> Ast "let" [happy_var_1,happy_var_3,x]-	)}}--happyReduce_64 = happyReduce 5# 8# 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 happyOut12 happy_x_1 of { happy_var_1 -> -	case happyOut7 happy_x_3 of { happy_var_3 -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn12-		 (\x -> happy_var_1(Ast "let" [happy_var_3,happy_var_5,x])-	) `HappyStk` happyRest}}}--happyReduce_65 = happySpecReduce_2  9# happyReduction_65-happyReduction_65 happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_2 of { happy_var_2 -> -	happyIn13-		 (\x -> Ast "predicate" [happy_var_2,x]-	)}--happyReduce_66 = happySpecReduce_0  9# happyReduction_66-happyReduction_66  =  happyIn13-		 (id-	)--happyReduce_67 = happySpecReduce_3  10# happyReduction_67-happyReduction_67 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut15 happy_x_3 of { happy_var_3 -> -	happyIn14-		 ((\x -> Ast "sortTuple" (x:(fst happy_var_3)),-                                                           \x -> Ast "sort" (x:(snd happy_var_3)))-	)}--happyReduce_68 = happySpecReduce_0  10# happyReduction_68-happyReduction_68  =  happyIn14-		 ((id,id)-	)--happyReduce_69 = happySpecReduce_2  11# happyReduction_69-happyReduction_69 happy_x_2-	happy_x_1-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	happyIn15-		 (([happy_var_1],[happy_var_2])-	)}}--happyReduce_70 = happyReduce 4# 11# happyReduction_70-happyReduction_70 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut15 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	case happyOut16 happy_x_4 of { happy_var_4 -> -	happyIn15-		 (((fst happy_var_1)++[happy_var_3],(snd happy_var_1)++[happy_var_4])-	) `HappyStk` happyRest}}}--happyReduce_71 = happySpecReduce_1  12# happyReduction_71-happyReduction_71 happy_x_1-	 =  happyIn16-		 (Avar "ascending"-	)--happyReduce_72 = happySpecReduce_1  12# happyReduction_72-happyReduction_72 happy_x_1-	 =  happyIn16-		 (Avar "descending"-	)--happyReduce_73 = happySpecReduce_0  12# happyReduction_73-happyReduction_73  =  happyIn16-		 (Avar "ascending"-	)--happyReduce_74 = happyReduce 4# 13# happyReduction_74-happyReduction_74 (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) -> -	happyIn17-		 (call "element" [Avar happy_var_3]-	) `HappyStk` happyRest}--happyReduce_75 = happyReduce 4# 13# happyReduction_75-happyReduction_75 (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) -> -	happyIn17-		 (call "attribute" [Avar happy_var_3]-	) `HappyStk` happyRest}--happyReduce_76 = happyReduce 6# 14# happyReduction_76-happyReduction_76 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut19 happy_x_1 of { happy_var_1 -> -	case happyOut20 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_5 of { (QName happy_var_5) -> -	happyIn18-		 (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: "++(show (head happy_var_1))++" '"++happy_var_5++"'")-	) `HappyStk` happyRest}}}--happyReduce_77 = happyReduce 5# 14# 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 happyOut19 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_4 of { (QName happy_var_4) -> -	happyIn18-		 (if head happy_var_1 == Astring happy_var_4-							     then Ast "construction" (happy_var_1++[call "empty" []])-                                                          else error("Unmatched tags in element construction: "++(show (head happy_var_1))++" '"++happy_var_4++"'")-	) `HappyStk` happyRest}}--happyReduce_78 = happySpecReduce_2  14# happyReduction_78-happyReduction_78 happy_x_2-	happy_x_1-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> -	happyIn18-		 (Ast "construction" (happy_var_1++[call "empty" []])-	)}--happyReduce_79 = happyReduce 7# 14# happyReduction_79-happyReduction_79 (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 happyOut8 happy_x_3 of { happy_var_3 -> -	case happyOut9 happy_x_6 of { happy_var_6 -> -	happyIn18-		 (Ast "element_construction" [happy_var_3,concatenateAll happy_var_6]-	) `HappyStk` happyRest}}--happyReduce_80 = happyReduce 7# 14# happyReduction_80-happyReduction_80 (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 happyOut8 happy_x_3 of { happy_var_3 -> -	case happyOut9 happy_x_6 of { happy_var_6 -> -	happyIn18-		 (Ast "attribute_construction" [happy_var_3,concatenateAll happy_var_6]-	) `HappyStk` happyRest}}--happyReduce_81 = happyReduce 5# 14# happyReduction_81-happyReduction_81 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_2 of { (QName happy_var_2) -> -	case happyOut9 happy_x_4 of { happy_var_4 -> -	happyIn18-		 (Ast "element_construction" [Astring happy_var_2,concatenateAll happy_var_4]-	) `HappyStk` happyRest}}--happyReduce_82 = happyReduce 5# 14# happyReduction_82-happyReduction_82 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_2 of { (QName happy_var_2) -> -	case happyOut9 happy_x_4 of { happy_var_4 -> -	happyIn18-		 (Ast "attribute_construction" [Astring happy_var_2,concatenateAll happy_var_4]-	) `HappyStk` happyRest}}--happyReduce_83 = happySpecReduce_2  15# happyReduction_83-happyReduction_83 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_2 of { (QName happy_var_2) -> -	happyIn19-		 ([Astring happy_var_2,Ast "attributes" []]-	)}--happyReduce_84 = happySpecReduce_3  15# happyReduction_84-happyReduction_84 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_2 of { (QName happy_var_2) -> -	case happyOut21 happy_x_3 of { happy_var_3 -> -	happyIn19-		 ([Astring happy_var_2,Ast "attributes" happy_var_3]-	)}}--happyReduce_85 = happySpecReduce_3  16# happyReduction_85-happyReduction_85 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut9 happy_x_2 of { happy_var_2 -> -	happyIn20-		 ([concatenateAll happy_var_2]-	)}--happyReduce_86 = happySpecReduce_1  16# happyReduction_86-happyReduction_86 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TString happy_var_1) -> -	happyIn20-		 ([Astring happy_var_1]-	)}--happyReduce_87 = happySpecReduce_1  16# happyReduction_87-happyReduction_87 happy_x_1-	 =  case happyOutTok happy_x_1 of { (XMLtext happy_var_1) -> -	happyIn20-		 ([Astring happy_var_1]-	)}--happyReduce_88 = happySpecReduce_1  16# happyReduction_88-happyReduction_88 happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	happyIn20-		 ([happy_var_1]-	)}--happyReduce_89 = happyReduce 4# 16# happyReduction_89-happyReduction_89 (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 happyOut9 happy_x_3 of { happy_var_3 -> -	happyIn20-		 (happy_var_1++[concatenateAll happy_var_3]-	) `HappyStk` happyRest}}--happyReduce_90 = happySpecReduce_2  16# happyReduction_90-happyReduction_90 happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (TString happy_var_2) -> -	happyIn20-		 (happy_var_1++[Astring happy_var_2]-	)}}--happyReduce_91 = happySpecReduce_2  16# happyReduction_91-happyReduction_91 happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (XMLtext happy_var_2) -> -	happyIn20-		 (happy_var_1++[Astring happy_var_2]-	)}}--happyReduce_92 = happySpecReduce_2  16# happyReduction_92-happyReduction_92 happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> -	case happyOut18 happy_x_2 of { happy_var_2 -> -	happyIn20-		 (happy_var_1++[happy_var_2]-	)}}--happyReduce_93 = happySpecReduce_3  17# happyReduction_93-happyReduction_93 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) -> -	happyIn21-		 ([Ast "pair" [Astring happy_var_1,Astring happy_var_3]]-	)}}--happyReduce_94 = happyReduce 5# 17# happyReduction_94-happyReduction_94 (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 happyOut8 happy_x_4 of { happy_var_4 -> -	happyIn21-		 ([Ast "pair" [Astring happy_var_1,happy_var_4]]-	) `HappyStk` happyRest}}--happyReduce_95 = happyReduce 4# 17# happyReduction_95-happyReduction_95 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut21 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) -> -	happyIn21-		 (happy_var_1++[Ast "pair" [Astring happy_var_2,Astring happy_var_4]]-	) `HappyStk` happyRest}}}--happyReduce_96 = happyReduce 6# 17# happyReduction_96-happyReduction_96 (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 happyOut21 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (QName happy_var_2) -> -	case happyOut8 happy_x_5 of { happy_var_5 -> -	happyIn21-		 (happy_var_1++[Ast "pair" [Astring happy_var_2,happy_var_5]]-	) `HappyStk` happyRest}}}--happyReduce_97 = happySpecReduce_1  18# happyReduction_97-happyReduction_97 happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	happyIn22-		 (Ast "step" (happy_var_1 "child_step" (Avar "."))-	)}--happyReduce_98 = happySpecReduce_2  18# happyReduction_98-happyReduction_98 happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_2 of { happy_var_2 -> -	happyIn22-		 (Ast "step" (happy_var_2 "attribute_step" (Avar "."))-	)}--happyReduce_99 = happySpecReduce_2  18# happyReduction_99-happyReduction_99 happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut23 happy_x_2 of { happy_var_2 -> -	happyIn22-		 (Ast "step" [happy_var_2 (Ast "step" (happy_var_1 "child_step" (Avar ".")))]-	)}}--happyReduce_100 = happySpecReduce_3  18# happyReduction_100-happyReduction_100 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_2 of { happy_var_2 -> -	case happyOut23 happy_x_3 of { happy_var_3 -> -	happyIn22-		 (Ast "step" (map happy_var_3 (happy_var_2 "attribute_step" (Avar ".")))-	)}}--happyReduce_101 = happySpecReduce_1  19# happyReduction_101-happyReduction_101 happy_x_1-	 =  case happyOut24 happy_x_1 of { happy_var_1 -> -	happyIn23-		 (happy_var_1-	)}--happyReduce_102 = happySpecReduce_2  19# happyReduction_102-happyReduction_102 happy_x_2-	happy_x_1-	 =  case happyOut23 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	happyIn23-		 (happy_var_2 . happy_var_1-	)}}--happyReduce_103 = happySpecReduce_2  20# happyReduction_103-happyReduction_103 happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_2 of { happy_var_2 -> -	happyIn24-		 (\e -> Ast "step" (happy_var_2 "child_step" e)-	)}--happyReduce_104 = happySpecReduce_3  20# happyReduction_104-happyReduction_104 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn24-		 (\e -> Ast "step" (happy_var_3 "attribute_step" e)-	)}--happyReduce_105 = happySpecReduce_3  20# happyReduction_105-happyReduction_105 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn24-		 (\e -> Ast "step" (happy_var_3 "descendant_step" e)-	)}--happyReduce_106 = happyReduce 4# 20# happyReduction_106-happyReduction_106 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut25 happy_x_4 of { happy_var_4 -> -	happyIn24-		 (\e -> Ast "step" (happy_var_4 "attribute_descendant_step" e)-	) `HappyStk` happyRest}--happyReduce_107 = happySpecReduce_2  20# happyReduction_107-happyReduction_107 happy_x_2-	happy_x_1-	 =  happyIn24-		 (\e -> Ast "step" [Ast "parent_step" [e]]-	)--happyReduce_108 = happySpecReduce_1  21# happyReduction_108-happyReduction_108 happy_x_1-	 =  case happyOut26 happy_x_1 of { happy_var_1 -> -	happyIn25-		 (\t e -> [happy_var_1 t e]-	)}--happyReduce_109 = happyReduce 4# 21# happyReduction_109-happyReduction_109 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_3 of { happy_var_3 -> -	happyIn25-		 (\t e -> (happy_var_1 t e)++[happy_var_3]-	) `HappyStk` happyRest}}--happyReduce_110 = happySpecReduce_1  22# happyReduction_110-happyReduction_110 happy_x_1-	 =  case happyOut27 happy_x_1 of { happy_var_1 -> -	happyIn26-		 (\t e -> happy_var_1 t e-	)}--happyReduce_111 = happySpecReduce_1  22# happyReduction_111-happyReduction_111 happy_x_1-	 =  happyIn26-		 (\t e -> Ast t [Astring "*",e]-	)--happyReduce_112 = happySpecReduce_1  22# happyReduction_112-happyReduction_112 happy_x_1-	 =  case happyOutTok happy_x_1 of { (QName happy_var_1) -> -	happyIn26-		 (\t e -> Ast t [Astring happy_var_1,e]-	)}--happyReduce_113 = happySpecReduce_1  23# happyReduction_113-happyReduction_113 happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	happyIn27-		 (\_ _ -> happy_var_1-	)}--happyReduce_114 = happySpecReduce_1  23# happyReduction_114-happyReduction_114 happy_x_1-	 =  happyIn27-		 (\_ e -> e-	)--happyReduce_115 = happySpecReduce_3  23# happyReduction_115-happyReduction_115 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut9 happy_x_2 of { happy_var_2 -> -	happyIn27-		 (\t e -> if e == Avar "."-                                                                     then concatenateAll happy_var_2-	                                                          else Ast "context" [e,Astring t,concatenateAll happy_var_2]-	)}--happyReduce_116 = happySpecReduce_2  23# happyReduction_116-happyReduction_116 happy_x_2-	happy_x_1-	 =  happyIn27-		 (\_ _ -> call "empty" []-	)--happyReduce_117 = happyReduce 4# 23# happyReduction_117-happyReduction_117 (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 happyOut9 happy_x_3 of { happy_var_3 -> -	happyIn27-		 (\_ e -> if e == Avar "."-                                                                     then call happy_var_1 happy_var_3-                                                                  else Ast "context" [e,call happy_var_1 happy_var_3]-	) `HappyStk` happyRest}}--happyReduce_118 = happySpecReduce_3  23# happyReduction_118-happyReduction_118 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (QName happy_var_1) -> -	happyIn27-		 (if elem happy_var_1 ["text"]-                                                             then \_ e -> call happy_var_1 [e]-                                                          else \_ _ -> call happy_var_1 []-	)}--happyNewToken action sts stk [] =-	happyDoAction 73# notHappyAtAll action sts stk []--happyNewToken action sts stk (tk:tks) =-	let cont i = happyDoAction i tk action sts stk tks in-	case tk of {-	RETURN -> cont 1#;-	SOME -> cont 2#;-	EVERY -> cont 3#;-	IF -> cont 4#;-	THEN -> cont 5#;-	ELSE -> cont 6#;-	LB -> cont 7#;-	RB -> cont 8#;-	LP -> cont 9#;-	RP -> cont 10#;-	LSB -> cont 11#;-	RSB -> cont 12#;-	LESCAPE -> cont 13#;-	RESCAPE -> cont 14#;-	TO -> cont 15#;-	PLUS -> cont 16#;-	MINUS -> cont 17#;-	TIMES -> cont 18#;-	DIV -> cont 19#;-	IDIV -> cont 20#;-	MOD -> cont 21#;-	TEQ -> cont 22#;-	TNE -> cont 23#;-	TLT -> cont 24#;-	TLE -> cont 25#;-	TGT -> cont 26#;-	TGE -> cont 27#;-	PRE -> cont 28#;-	POST -> cont 29#;-	IS -> cont 30#;-	SEQ -> cont 31#;-	SNE -> cont 32#;-	SLT -> cont 33#;-	SLE -> cont 34#;-	SGT -> cont 35#;-	SGE -> cont 36#;-	AND -> cont 37#;-	OR -> cont 38#;-	NOT -> cont 39#;-	UNION -> cont 40#;-	INTERSECT -> cont 41#;-	EXCEPT -> cont 42#;-	FOR -> cont 43#;-	LET -> cont 44#;-	IN -> cont 45#;-	COMMA -> cont 46#;-	ASSIGN -> cont 47#;-	WHERE -> cont 48#;-	ORDER -> cont 49#;-	BY -> cont 50#;-	ASCENDING -> cont 51#;-	DESCENDING -> cont 52#;-	ELEMENT -> cont 53#;-	ATTRIBUTE -> cont 54#;-	STAG -> cont 55#;-	ETAG -> cont 56#;-	SATISFIES -> cont 57#;-	ATSIGN -> cont 58#;-	SLASH -> cont 59#;-	QName happy_dollar_dollar -> cont 60#;-	DECLARE -> cont 61#;-	FUNCTION -> cont 62#;-	VARIABLE -> cont 63#;-	AT -> cont 64#;-	DOTS -> cont 65#;-	DOT -> cont 66#;-	SEMI -> cont 67#;-	Variable happy_dollar_dollar -> cont 68#;-	XMLtext happy_dollar_dollar -> cont 69#;-	TInteger happy_dollar_dollar -> cont 70#;-	TFloat happy_dollar_dollar -> cont 71#;-	TString happy_dollar_dollar -> cont 72#;-	_ -> 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 0# tks) (\x -> happyReturn (happyOut4 x))--happySeq = happyDontSeq----- Abstract Syntax Tree for XQueries-data Ast = Ast String [Ast]-         | Avar String-         | Aint Int-         | Afloat Float-         | Astring String-         deriving Eq---instance Show Ast-  where show (Ast s []) = s ++ "()"-        show (Ast s (x:xs)) = s ++ "(" ++ (show x)-                              ++ (foldr (\a r -> ","++(show a)++r) "" xs)-                              ++ ")"-        show (Avar s) = s-        show (Aint n) = show n-        show (Afloat n) = show n-        show (Astring s) = "\'" ++ s ++ "\'"---call :: String -> [Ast] -> Ast-call name args = Ast "call" ((Avar name):args)---concatenateAll :: [Ast] -> Ast-concatenateAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs-concatenateAll _ = call "empty" []---concatAll :: [Ast] -> Ast-concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs-concatAll _ = call "empty" []---data Token-  = RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB-  | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD-  | TEQ | TNE | TLT | TLE | TGT | TGE | SEQ | SNE | SLT | SLE | SGT | SGE-  | AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA-  | ASSIGN | WHERE | ORDER | BY | ASCENDING | DESCENDING | ELEMENT-  | ATTRIBUTE | STAG | ETAG | SATISFIES | ATSIGN | SLASH | DECLARE | SEMI-  | FUNCTION | VARIABLE |AT | DOT | DOTS | TokenEOF | PRE | POST | IS-  | QName String | Variable String | XMLtext String | TInteger Int-  | TFloat Float | TString String | TError String-    deriving Eq---instance Show Token-    where show (QName s) = "QName("++s++")"-	  show (Variable s) = "Variable("++s++")"-	  show (XMLtext s) = "XMLtext("++s++")"-	  show (TInteger n) = "Integer("++(show n)++")"-	  show (TFloat n) = "Double("++(show n)++")"-	  show (TString s) = "String("++s++")"-          show t = case filter (\(n,_) -> n==t) tokenList of-                     (_,b):_ -> b-                     _ -> "Illegal token"---tokenList :: [(Token,String)]-tokenList = [(RETURN,"return"),(SOME,"some"),(EVERY,"every"),(IF,"if"),(THEN,"then"),(ELSE,"else"),-             (LB,"["),(RB,"]"),(LP,"("),(RP,")"),(LSB,"{"),(RSB,"}"),(LESCAPE,"\"{"),(RESCAPE,"}\""),-             (TO,"to"),(PLUS,"+"),(MINUS,"-"),(TIMES,"*"),(DIV,"div"),(IDIV,"idiv"),(MOD,"mod"),-             (TEQ,"="),(TNE,"!="),(TLT,"<"),(TLE,"<="),(TGT,">"),(TGE,">="),(PRE,"<<"),(POST,">>"),-             (IS,"is"),(SEQ,"eq"),(SNE,"ne"),(SLT,"lt"),(SLE,"le"),(SGT,"gt"),(SGE,"ge"),(AND,"and"),-             (OR,"or"),(NOT,"not"),(UNION,"union"),(INTERSECT,"intersect"),(EXCEPT,"except"),-             (FOR,"for"),(LET,"let"),(IN,"in"),(COMMA,"','"),(ASSIGN,":="),(WHERE,"where"),(ORDER,"order"),-             (BY,"by"),(ASCENDING,"ascending"),(DESCENDING,"descending"),(ELEMENT,"element"),-             (ATTRIBUTE,"attribute"),(STAG,"</"),(ETAG,"/>"),(SATISFIES,"satisfies"),(ATSIGN,"@"),-             (SLASH,"/"),(DECLARE,"declare"),(FUNCTION,"function"),(VARIABLE,"variable"),-             (AT,"at"),(DOTS,".."),(DOT,"."),(SEMI,";")]---parseError [] = error "Reached end-of-input"-parseError [_] = error "Reached end-of-input"-parseError tk = error("Parse error: "++(show (take 10 (init tk))))---scan :: String -> [Token]-scan cs = lexer cs [0]--xmlText :: String -> [Token]-xmlText "" = []-xmlText text = [XMLtext text]---- scans XML syntax and returns an XMLtext token with the text-xml :: String -> String -> [Int] -> [Token]-xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n))-xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n)-xml ('<':'!':'-':cs) text n = xmlComment cs (text++"<!-") n-xml ('<':cs) text (k:n) = (xmlText text)++(TLT : lexer cs (k+2:n))-xml ('\'':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)-xml ('\"':'{':cs) text n = (xmlText text)++(LESCAPE : lexer cs n)-xml ('(':':':cs) text n = xqComment cs text n-xml (c:cs) text n = xml cs (text++[c]) n-xml [] text _ = xmlText text--xqComment :: String -> String -> [Int] -> [Token]-xqComment (':':')':cs) text n = xml cs text n-xqComment (_:cs) text n = xqComment cs text n-xqComment [] text _ = xmlText text--xmlComment :: String -> String -> [Int] -> [Token]-xmlComment ('-':'>':cs) text n = xml cs (text++"->") n-xmlComment (c:cs) text n = xmlComment cs (text++[c]) n-xmlComment [] text _ = xmlText text--isQN :: Char -> Bool-isQN c = elem c "_:-" || isDigit c || isAlpha c--isVar :: Char -> Bool-isVar c = elem c "_" || isDigit c || isAlpha c---- the XQuery scanner-lexer :: String -> [Int] -> [Token]-lexer [] [0] = []-lexer [] _ = error "Unbalanced tags"-lexer (' ':'>':' ':cs) n = TGT : lexer cs n-lexer (c:cs) n-      | isSpace c = lexer cs n-      | isAlpha c = lexVar (c:cs) n-      | isDigit c = lexNum (c:cs) n-lexer ('$':c:cs) n | isAlpha c-      = let (var,rest) = span isVar (c:cs)-        in (Variable var) : lexer rest n-lexer ('\'':'{':cs) n = LESCAPE : lexer cs n-lexer ('\"':'{':cs) n = LESCAPE : lexer cs n-lexer (':':'=':cs) n = ASSIGN : lexer cs n-lexer ('<':'/':cs) n = STAG : lexer cs n-lexer ('<':'=':cs) n = TLE : lexer cs n-lexer ('>':'=':cs) n = TGE : lexer cs n-lexer ('<':'<':cs) n = PRE : lexer cs n-lexer ('>':'>':cs) n = POST : lexer cs n-lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)-lexer ('(':':':cs) n = lexComment cs n-lexer ('<':'!':'-':cs) n = lexXmlComment cs "<!-" n-lexer ('.':'.':cs) n = DOTS : lexer cs n-lexer ('.':cs) n = DOT : lexer cs n-lexer ('}':'\'':cs) n = RESCAPE : lexer cs n-lexer ('}':'\"':cs) n = RESCAPE : lexer cs n-lexer ('!':'=':cs) n = TNE : lexer cs n-lexer ('\'':cs) n = lexString cs n-lexer ('\"':cs) n = lexString2 cs n-lexer ('[':cs) n = LB : lexer cs n-lexer (']':cs) n = RB : lexer cs n-lexer ('(':cs) n = LP : lexer cs n-lexer (')':cs) n = RP : lexer cs n-lexer ('}':cs) [_,n] = RSB : lexer cs [n]-lexer ('}':cs) (_:n:ns) = RSB : (if n==0 then lexer cs (n:ns) else xml cs "" (n:ns))-lexer ('+':cs) n = PLUS : lexer cs n-lexer ('-':cs) n = MINUS : lexer cs n-lexer ('*':cs) n = TIMES : lexer cs n-lexer ('=':cs) n = TEQ : lexer cs n-lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n-lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n)-lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (0:n) else xml cs "" (k-1:n))-lexer (',':cs) n = COMMA : lexer cs n-lexer ('@':cs) n = ATSIGN : lexer cs n-lexer ('/':cs) n = SLASH : lexer cs n-lexer ('{':cs) n = LSB : lexer cs (0:n)-lexer ('|':cs) n = UNION : lexer cs n-lexer (';':cs) n = SEMI : lexer cs n-lexer (c:cs) n = error("Illegal character "++[c])--lexNum :: String -> [Int] -> [Token]-lexNum cs n = if null rest || head rest /= '.'-                 then TInteger (read k) : lexer rest n-              else let (m,rest2) = span isDigit (tail rest)-                       val::Float = read (k++('.':m))-                   in case rest2 of-                        ('e':rest3) -> let (exp,rest4) = span isDigit rest3-                                       in (TFloat (val*10^(read exp))) : lexer rest4 n-                        _ -> (TFloat val) : lexer rest2 n-      where (k,rest) = span isDigit cs--lexString :: String -> [Int] -> [Token]-lexString cs n = TString s : lexer (tail rest) n-    where (s,rest) = span inString cs-          inString c = c /= '\''--lexString2 :: String -> [Int] -> [Token]-lexString2 cs n = TString s : lexer (tail rest) n-    where (s,rest) = span inString cs-          inString c = c /= '\"'--lexComment :: String -> [Int] -> [Token]-lexComment (':':')':cs) n = lexer cs n-lexComment (_:cs) n = lexComment cs n-lexComment [] n = []--lexXmlComment :: String -> String -> [Int] -> [Token]-lexXmlComment ('-':'>':cs) text n = (xmlText (text++"->"))++(lexer cs n)-lexXmlComment (c:cs) text n = lexXmlComment cs (text++[c]) n-lexXmlComment [] text _ = xmlText text--lexVar :: String -> [Int] -> [Token]-lexVar cs n =-   case span isQN cs of-      ("return",rest) -> RETURN : lexer rest n-      ("some",rest) -> SOME : lexer rest n-      ("every",rest) -> EVERY : lexer rest n-      ("if",rest) -> IF : lexer rest n-      ("then",rest) -> THEN : lexer rest n-      ("else",rest) -> ELSE : lexer rest n-      ("to",rest) -> TO : lexer rest n-      ("div",rest) -> DIV : lexer rest n-      ("idiv",rest) -> IDIV : lexer rest n-      ("mod",rest) -> MOD : lexer rest n-      ("and",rest) -> AND : lexer rest n-      ("or",rest) -> OR : lexer rest n-      ("not",rest) -> NOT : lexer rest n-      ("union",rest) -> UNION : lexer rest n-      ("intersect",rest) -> INTERSECT : lexer rest n-      ("except",rest) -> EXCEPT : lexer rest n-      ("for",rest) -> FOR : lexer rest n-      ("let",rest) -> LET : lexer rest n-      ("in",rest) -> IN : lexer rest n-      ("where",rest) -> WHERE : lexer rest n-      ("order",rest) -> ORDER : lexer rest n-      ("by",rest) -> BY : lexer rest n-      ("ascending",rest) -> ASCENDING : lexer rest n-      ("descending",rest) -> DESCENDING : lexer rest n-      ("element",rest) -> ELEMENT : lexer rest n-      ("attribute",rest) -> ATTRIBUTE : lexer rest n-      ("satisfies",rest) -> SATISFIES : lexer rest n-      ("declare",rest) -> DECLARE : lexer rest n-      ("function",rest) -> FUNCTION : lexer rest n-      ("variable",rest) -> VARIABLE : lexer rest n-      ("at",rest) -> AT : lexer rest n-      ("eq",rest) -> SEQ : lexer rest n-      ("ne",rest) -> SNE : lexer rest n-      ("lt",rest) -> SLT : lexer rest n-      ("le",rest) -> SLE : lexer rest n-      ("gt",rest) -> SGT : lexer rest n-      ("ge",rest) -> SGE : lexer rest n-      ("is",rest) -> IS : lexer rest n-      (var,rest) -> QName var : lexer rest n-{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "<built-in>" #-}-{-# LINE 1 "<command line>" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp --{-# LINE 28 "templates/GenericTemplate.hs" #-}---data Happy_IntList = HappyCons Int# Happy_IntList------{-# 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 0#, it means we've just accepted a partial--- parse (a %partial parser).  We must ignore the saved token on the top of--- the stack in this case.-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =-	happyReturn1 ans-happyAccept j tk st sts (HappyStk ans _) = -	(happyTcHack j (happyTcHack st)) (happyReturn1 ans)---------------------------------------------------------------------------------- Arrays only: do the next action----happyDoAction i tk st-	= {- nothing -}---	  case action of-		0#		  -> {- nothing -}-				     happyFail i tk st-		-1# 	  -> {- nothing -}-				     happyAccept i tk st-		n | (n <# (0# :: Int#)) -> {- nothing -}--				     (happyReduceArr ! rule) i tk st-				     where rule = (I# ((negateInt# ((n +# (1# :: Int#))))))-		n		  -> {- nothing -}---				     happyShift new_state i tk st-				     where new_state = (n -# (1# :: Int#))-   where off    = indexShortOffAddr happyActOffsets st-	 off_i  = (off +# i)-	 check  = if (off_i >=# (0# :: Int#))-			then (indexShortOffAddr happyCheck off_i ==#  i)-			else False- 	 action | check     = indexShortOffAddr happyTable off_i-		| otherwise = indexShortOffAddr happyDefActions st--{-# LINE 127 "templates/GenericTemplate.hs" #-}---indexShortOffAddr (HappyA# arr) off =-#if __GLASGOW_HASKELL__ > 500-	narrow16Int# i-#elif __GLASGOW_HASKELL__ == 500-	intToInt16# i-#else-	(i `iShiftL#` 16#) `iShiftRA#` 16#-#endif-  where-#if __GLASGOW_HASKELL__ >= 503-	i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)-#else-	i = word2Int# ((high `shiftL#` 8#) `or#` low)-#endif-	high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))-	low  = int2Word# (ord# (indexCharOffAddr# arr off'))-	off' = off *# 2#------data HappyAddr = HappyA# Addr#------------------------------------------------------------------------------------- HappyState data type (not arrays)--{-# LINE 170 "templates/GenericTemplate.hs" #-}---------------------------------------------------------------------------------- Shifting a token--happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =-     let i = (case unsafeCoerce# x of { (I# (i)) -> i }) in---     trace "shifting the error token" $-     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)--happyShift new_state i tk st sts stk =-     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)---- happyReduce is specialised for the common cases.--happySpecReduce_0 i fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happySpecReduce_0 nt fn j tk st@((action)) sts stk-     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)--happySpecReduce_1 i fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')-     = let r = fn v1 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_2 i fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')-     = let r = fn v1 v2 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_3 i fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')-     = let r = fn v1 v2 v3 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happyReduce k i fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happyReduce k nt fn j tk st sts stk-     = case happyDrop (k -# (1# :: Int#)) sts of-	 sts1@((HappyCons (st1@(action)) (_))) ->-        	let r = fn stk in  -- it doesn't hurt to always seq here...-       		happyDoSeq r (happyGoto nt j tk st1 sts1 r)--happyMonadReduce k nt fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happyMonadReduce k nt fn j tk st sts stk =-        happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))-       where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts))-             drop_stk = happyDropStk k stk--happyMonad2Reduce k nt fn 0# tk st sts stk-     = happyFail 0# tk st sts stk-happyMonad2Reduce k nt fn j tk st sts stk =-       happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))-       where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts))-             drop_stk = happyDropStk k stk--             off    = indexShortOffAddr happyGotoOffsets st1-             off_i  = (off +# nt)-             new_state = indexShortOffAddr happyTable off_i-----happyDrop 0# l = l-happyDrop n (HappyCons (_) (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---happyGoto nt j tk st = -   {- nothing -}-   happyDoAction j tk new_state-   where off    = indexShortOffAddr happyGotoOffsets st-	 off_i  = (off +# nt)- 	 new_state = indexShortOffAddr happyTable off_i------------------------------------------------------------------------------------- Error recovery (0# is the error token)---- parse error if we are in recovery and we fail again-happyFail  0# tk old_st _ stk =---	trace "failing" $ -    	happyError_ tk--{-  We don't need state discarding for our restricted implementation of-    "error".  In fact, it can cause some bogus parses, so I've disabled it-    for now --SDM---- discard a state-happyFail  0# tk old_st (HappyCons ((action)) (sts)) -						(saved_tok `HappyStk` _ `HappyStk` stk) =---	trace ("discarding state, depth " ++ show (length stk))  $-	happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))--}---- Enter error recovery: generate an error token,---                       save the old token and carry on.-happyFail  i tk (action) sts stk =---      trace "entering error recovery" $-	happyDoAction 0# tk action sts ( (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.---{-# NOINLINE happyDoAction #-}-{-# NOINLINE happyTable #-}-{-# NOINLINE happyCheck #-}-{-# NOINLINE happyActOffsets #-}-{-# NOINLINE happyGotoOffsets #-}-{-# NOINLINE happyDefActions #-}--{-# NOINLINE happyShift #-}-{-# NOINLINE happySpecReduce_0 #-}-{-# NOINLINE happySpecReduce_1 #-}-{-# NOINLINE happySpecReduce_2 #-}-{-# NOINLINE happySpecReduce_3 #-}-{-# NOINLINE happyReduce #-}-{-# NOINLINE happyMonadReduce #-}-{-# NOINLINE happyGoto #-}-{-# NOINLINE happyFail #-}---- end of Happy Template.

@@ -14,7 +14,7 @@ --------------------------------------------------------------------------------------}  {-module XQueryParser where+module XML.HXQ.Parser where import Char } 

@@ -1,101 +0,0 @@-{----------------------------------------------------------------------------------------- XML Trees (rose trees)-- Programmer: Leonidas Fegaras-- Email: fegaras@cse.uta.edu-- Web: http://lambda.uta.edu/-- Creation: 05/01/08, last update: 05/01/08-- -- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.-- This material is provided as is, with absolutely no warranty expressed or implied.-- Any use is at your own risk. Permission is hereby granted to use or copy this program-- for any purpose, provided the above notices are retained on all copies.-----------------------------------------------------------------------------------------}---{-# OPTIONS_GHC -funbox-strict-fields #-}---module XTree where--import System.IO-import XMLParse(XMLEvent(..))-import HXML(AttList)---type Tag = String----- A DOM-like tree to represent XML data--- Int in XElem is the preorder numbering used for document order-data XTree =  XElem    !Tag !AttList !Int [XTree]-           |  XText    !String-           |  XInt     !Int-           |  XFloat   !Float-           |  XBool    !Bool-           |  XPI      Tag String	-- processing instruction-           |  XGERef   Tag		-- general entity reference-           |  XComment String		-- comment-           |  XError   String		-- error report-           deriving Eq--type XSeq = [XTree]---showAL :: AttList -> String-showAL = foldr(\(a,v) r -> " "++a++"=\""++v++"\""++r) []--showXT :: XTree -> Bool -> String-showXT e pad-    = case e of-        XElem tag al _ [] -> "<"++tag++(showAL al)++"/>"-        XElem tag al _ xs -> "<"++tag++(showAL al)++">"++(showXS xs)++"</"++tag++">"-        XText text -> text-        XInt n -> p++(show n)-        XFloat n -> p++(show n)-        XBool v -> p++(if v then "true" else "false")-        XComment s -> "<!--"++s++"-->"-        XPI n s -> "<?"++n++" "++s++">"-        XError s -> error s-        _ -> ""-      where p = if pad then " " else ""--showXS :: XSeq -> String-showXS [] = ""-showXS (x:xs) = (showXT x False) ++ (concatMap (\x -> showXT x True) xs)--instance Show XTree where-    show t = showXT t False----- print an XSeq without waiting-putXSeq :: XSeq -> IO ()-putXSeq xs = hSetBuffering stdout NoBuffering >> putStrLn (showXS xs)---{--------------- Build the rose tree from the XML stream ----------------------------}---type Stream = [XMLEvent]----- lazily materialize the SAX stream into a DOM tree-materialize :: Stream -> XTree-materialize stream = XElem "document" [] 1 [head (filter (\x -> case x of XElem _ _ _ _ -> True; _ -> False)-                                                         ((\(x,_,_)->x) (ml stream 2)))]-        where m ((TextEvent t):xs) i = (XText t,xs,i)-              m ((EmptyEvent n atts):xs) i = (XElem n atts i [],xs,i+1)-              m ((StartEvent n atts):xs) i = let (el,xs',i') = ml xs (i+1)-                                             in (XElem n atts i el,xs',i')-              m ((PIEvent n s):xs) i = (XPI n s,xs,i)-              m ((CommentEvent s):xs) i = (XComment s,xs,i)-              m ((GERefEvent n):xs) i = (XGERef n,xs,i)-              m ((ErrorEvent s):xs) i = (XError s,xs,i)-              m (_:xs) i = (XError "unrecognized XML event",xs,i)-              m [] i = (XError "unbalanced tags",[],i)-              ml [] i = ([],[],i)-              ml ((EndEvent n):xs) i = ([],xs,i)-              ml xs i = let (e,xs',i') = m xs i-                            (el,xs'',i'') = ml xs' i'-                        in (e:el,xs'',i'')

@@ -0,0 +1,189 @@+create table employee+	( fname		varchar(15)	not null,+	  minit		char,+	  lname		varchar(15)	not null,+	  ssn		char(9)		primary key not null,+	  dno		int		references department(dnumber),+	  bdate		date,+	  address	varchar(30),+	  sex		char,+	  salary	decimal(10,2),+	  superssn	char(9)		references employee(ssn) );+++create table department+	( dname		varchar(15)	unique not null,+	  dnumber	int		primary key not null,+	  mgrssn	char(9)		references employee(ssn),+	  mgrstartdate	date		);+++create table dept_locations+	( dnumber	int		not null references department(dnumber),+	  dlocation	varchar(15)	not null,+	primary key (dnumber,dlocation) );+++create table project+	( pname		varchar(15)	unique not null,+	  pnumber	int		primary key not null,+	  plocation	varchar(15),+	  dnum		int		references department(dnumber) );+++create table works_on+	( essn		char(9)		not null references employee(ssn),+	  pno		int		not null references project(pnumber),+	  hours		decimal(3,1),+	primary key (essn,pno)		);+++create table dependent+	( essn		char(9)		not null references employee(ssn),+	  dependent_name varchar(15)	not null,+	  sex		char,+	  bdate		date,+	  relationship	varchar(8),+	primary key (essn,dependent_name) );++++insert into department+	values ( 'Research', 5, '22-MAY-78', 333445555 );++insert into department+	values ( 'Administration', 4, '01-JAN-85', 987654321 );++insert into department+	values ( 'Headquarters', 1, '19-JUN-71', 888665555 );+++insert into employee+	values ( 'James', 'E', 'Borg', 888665555, 1, '10-NOV-27', '450 Stone, Houston, TX', 'M', 55000, null );++insert into employee+	values	( 'Franklin', 'T', 'Wong', 333445555, 5, '18-DEC-45', '638 Voss, Houston, TX', 'M', 40000, 888665555);++insert into employee+	values	( 'John', 'B', 'Smith', 123456789, 5, '09-JAN-55', '731 Fondren, Houston, TX', 'M', 30000, 333445555 );++insert into employee+	values	( 'Jennifer', 'S', 'Wallace', 987654321, 4, '20-JUN-31', '291 Berry, Bellair, TX', 'F', 43000, 888665555 );++insert into employee+	values	( 'Alicia', 'J', 'Zelaya', 999887777, 4, '19-JUL-58', '3321 Castle, Spring, TX', 'F', 25000, 987654321 );++insert into employee+	values	( 'Ramesh', 'K', 'Narayan', 666884444, 5, '15-SEP-52', '975 Fire Oak, Humble, TX', 'M', 38000, 333445555 );++insert into employee+	values	( 'Joyce', 'A', 'English', 453453453, 5, '31-JUL-62', '5631 Rice, Houston, TX', 'F', 25000, 333445555 );++insert into employee+	values	( 'Ahmad', 'V', 'Jabbar', 987987987, 1, '29-MAR-59', '980 Dallas, Houston, TX', 'M', 25000, 987654321 );+++insert into dept_locations+	values ( 1, 'Houston' );++insert into dept_locations+	values ( 4, 'Stafford' );++insert into dept_locations+	values ( 5, 'Bellaire' );++insert into dept_locations+	values ( 5, 'Sugarland' );++insert into dept_locations+	values ( 5, 'Houston' );+++insert into project+	values ( 'ProductX', 1, 'Bellaire', 5 );++insert into project+	values ( 'ProductY', 2, 'Sugarland', 5 );++insert into project+	values ( 'ProductZ', 3, 'Houston', 5 );++insert into project+	values ( 'Computerization', 10, 'Stafford', 4 );++insert into project+	values ( 'Reorganization', 20, 'Houston', 1 );++insert into project+	values ( 'Newbenefits', 30, 'Stafford', 4 );+++insert into works_on+	values ( 123456789, 1, 32.5 );++insert into works_on+	values ( 123456789, 2, 7.5 );++insert into works_on+	values ( 666884444, 3, 40.0 );++insert into works_on+	values ( 453453453, 1, 20.0 );++insert into works_on+	values ( 453453453, 2, 20.0 );++insert into works_on+	values ( 333445555, 2, 10.0 );++insert into works_on+	values ( 333445555, 3, 10.0 );++insert into works_on+	values ( 333445555, 10, 10.0 );++insert into works_on+	values ( 333445555, 20, 10.0 );++insert into works_on+	values ( 999887777, 30, 30.0 );++insert into works_on+	values ( 999887777, 10, 10.0 );++insert into works_on+	values ( 987987987, 10, 35.0 );++insert into works_on+	values ( 987987987, 30, 5.0 );++insert into works_on+	values ( 987654321, 30, 20.0 );++insert into works_on+	values ( 987654321, 20, 15.0 );++insert into works_on+	values ( 888665555, 20, null );+++insert into dependent+	values ( 333445555, 'Alice', 'F', '05-APR-76', 'DAUGHTER' );++insert into dependent+	values ( 333445555, 'Theodore', 'M', '25-OCT-73', 'SON' );++insert into dependent+	values ( 333445555, 'Joy', 'F', '03-MAR-48', 'SPOUSE' );++insert into dependent+	values ( 987654321, 'Abner', 'M', '29-FEB-32', 'SPOUSE' );++insert into dependent+	values ( 123456789, 'Michael', 'M', '01-JAN-78', 'SON' );++insert into dependent+	values ( 123456789, 'Alice', 'F', '31-DEC-78', 'DAUGHTER' );++insert into dependent+	values ( 123456789, 'Elizabeth', 'F', '05-MAY-57', 'SPOUSE' );

@@ -43,7 +43,7 @@ <pre> yum install ghc happy </pre>-Then download <a href="/HXQ-0.7.4.tar.gz">HXQ</a> and untar it.+Then download <a href="/HXQ-0.8.tar.gz">HXQ</a> and untar it. You can use either make or cabal to build it. To build it with cabal, you do: <pre> runhaskell Setup.lhs configure --prefix=$HOME@@ -64,7 +64,8 @@ Some, but not all, parent axis steps are removed using optimization rules; all others cause a compilation error. Finally, the XQuery semantics requires duplicate elimination and sorting by document order for every XPath step, which is very expensive and unnecessary in most cases.-This will be addressed in the future (needs a static analysis to determine when is necessary).+For exmple, <tt>e//*//*</tt> may return duplicate elements in HXQ.+This will be addressed in the future (needs a static analysis to determine when duplicate elimination is necessary). <p> <h2>Using the Compiler</h2> <p>@@ -130,7 +131,26 @@ <tt>xquery -p "//inproceedings[100]" data/dblp.xml</tt>. With <tt>xquery -help</tt> you get the list of system functions and usage information.  <p>-There is an experimental+<h2>Experimental Features</h2>+<p>+There is an experimental interface to HDBC to query relational data inside an XQuery.+To use it, you need to install <a href="http://hackage.haskell.org/cgi-bin/hackage-scripts/package/HDBC">HDBC</a>+and <a href="http://hackage.haskell.org/cgi-bin/hackage-scripts/package/HDBC-sqlite3">HDBC-sqlite3</a>+(or some other HDBC driver, such ODBC). The main function is+<tt>$(xqdb query) :: (IConnection conn) => conn -> IO XSeq</tt>.+The XQuery may contain multiple SQL queries in the form <tt>sql(query,args)</tt>,+where <tt>query</tt> is the sql query that may contain parameters (denoted by ?), which are bound to the values in <tt>args</tt>.+An example can be found in <a href="TestDB.hs">TestDB.hs</a>. To run it, you need+to install the <a href="data/company.sql">company</a> database. For example, using the sqlite3+interpreter, you do:+<pre>+sqlite3 myDB+.read data/company.sql+.quit+</pre>+and then you do <tt>make testdb</tt> on linux.+<p>+Finally, there is an experimental program, called <tt>hxqc</tt>, that works like <tt>xquery</tt> but is faster because it uses the HXQ compiler instead of the interpreter. It's constracted with the Unix Makefile (<tt>make hxqc</tt>). It is unstable and the <tt>hxqc</tt> executable is 10 times larger than <tt>xquery</tt> since it@@ -141,4 +161,4 @@ <p> <hr> <p>-<address>Last modified: 05/03/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>+<address>Last modified: 05/13/08 by <a href="http://lambda.uta.edu/">Leonidas Fegaras</a></address>

@@ -2,9 +2,9 @@  module Main where -import XTree-import XQueryParser-import XQueryCompiler+import XML.HXQ.XTree+import XML.HXQ.Parser+import XML.HXQ.Compiler import XMLParse(parseDocument) import IO